]> 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 GraphicsOutput 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
6fcf7288
HL		 1097/**\r
1098 Function to dump information about DebugSupport 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
1107DebugSupportProtocolDumpInformation (\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_DEBUG_SUPPORT_PROTOCOL *DebugSupport;\r
1114 CHAR16 *GetString;\r
1115 CHAR16 *RetVal;\r
1116\r
1117 if (!Verbose) {\r
1118 return NULL;\r
1119 }\r
1120 GetString = NULL;\r
1121 RetVal = NULL;\r
1122 Status = gBS->OpenProtocol (\r
1123 TheHandle,\r
1124 &gEfiDebugSupportProtocolGuid,\r
1125 (VOID**)&DebugSupport,\r
1126 gImageHandle,\r
1127 NULL,\r
1128 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1129 );\r
1130 if (EFI_ERROR (Status)) {\r
1131 return NULL;\r
1132 }\r
1133 HandleParsingHiiInit ();\r
1134 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_INFO), NULL);\r
1135 if (GetString == NULL) {\r
1136 return NULL;\r
1137 }\r
1138 //\r
1139 // Dump Debug support info\r
1140 //\r
1141 switch (DebugSupport->Isa) {\r
1142 case (IsaIa32):\r
1143 RetVal = CatSPrint (RetVal, GetString, L"IA-32");\r
1144 break;\r
1145 case (IsaIpf):\r
1146 RetVal = CatSPrint (RetVal, GetString, L"IPF");\r
1147 break;\r
1148 case (IsaEbc):\r
1149 RetVal = CatSPrint (RetVal, GetString, L"EBC");\r
1150 break;\r
1151 default:\r
1152 SHELL_FREE_NON_NULL (GetString);\r
1153 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN), NULL);\r
1154 RetVal = GetString != NULL ? CatSPrint (RetVal, GetString, DebugSupport->Isa) : NULL;\r
1155 break;\r
1156 }\r
1157\r
1158 SHELL_FREE_NON_NULL (GetString);\r
1159 return RetVal;\r
1160}\r
1161\r
59febea1
SEHM		 1162/**\r
1163 Function to dump information about EfiAdapterInformation Protocol.\r
1164\r
1165 @param[in] TheHandle The handle that has the protocol installed.\r
1166 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
1167\r
1168 @retval A pointer to a string containing the information.\r
1169**/\r
1170CHAR16*\r
1171EFIAPI\r
1172AdapterInformationDumpInformation (\r
1173 IN CONST EFI_HANDLE TheHandle,\r
1174 IN CONST BOOLEAN Verbose\r
1175 )\r
1176{\r
1177 EFI_STATUS Status;\r
1178 EFI_ADAPTER_INFORMATION_PROTOCOL *EfiAdptrInfoProtocol;\r
1179 UINTN InfoTypesBufferCount;\r
1180 UINTN GuidIndex;\r
1181 EFI_GUID *InfoTypesBuffer;\r
1182 CHAR16 *GuidStr;\r
1183 CHAR16 *TempStr;\r
1184 CHAR16 *RetVal;\r
1a6f74d9 1185 CHAR16 *TempRetVal;\r
59febea1
SEHM		 1186 VOID *InformationBlock;\r
1187 UINTN InformationBlockSize;\r
1a6f74d9 1188\r
59febea1
SEHM		 1189 if (!Verbose) {\r
1190 return (CatSPrint(NULL, L"AdapterInfo"));\r
1191 }\r
1192\r
1d6ccad2
QS		 1193 InfoTypesBuffer = NULL;\r
1194 InformationBlock = NULL;\r
1a6f74d9 1195\r
59febea1
SEHM		 1196\r
1197 Status = gBS->OpenProtocol (\r
1198 (EFI_HANDLE) (TheHandle),\r
1199 &gEfiAdapterInformationProtocolGuid,\r
1200 (VOID **) &EfiAdptrInfoProtocol,\r
1201 NULL,\r
1202 NULL,\r
1203 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1204 );\r
1205\r
1206 if (EFI_ERROR (Status)) {\r
59febea1
SEHM		 1207 return NULL;\r
1208 }\r
1209\r
1210 //\r
1211 // Get a list of supported information types for this instance of the protocol.\r
1212 //\r
1213 Status = EfiAdptrInfoProtocol->GetSupportedTypes (\r
1214 EfiAdptrInfoProtocol,\r
1a6f74d9 1215 &InfoTypesBuffer,\r
59febea1
SEHM		 1216 &InfoTypesBufferCount\r
1217 );\r
1a6f74d9 1218 RetVal = NULL;\r
59febea1
SEHM		 1219 if (EFI_ERROR (Status)) {\r
1220 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED), NULL);\r
1d6ccad2 1221 if (TempStr != NULL) {\r
1a6f74d9 1222 RetVal = CatSPrint (NULL, TempStr, Status);\r
1d6ccad2
QS		 1223 } else {\r
1224 goto ERROR_EXIT;\r
1a6f74d9 1225 }\r
59febea1
SEHM		 1226 } else {\r
1227 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SUPP_TYPE_HEADER), NULL);\r
1d6ccad2
QS		 1228 if (TempStr == NULL) {\r
1229 goto ERROR_EXIT;\r
1230 }\r
1a6f74d9 1231 RetVal = CatSPrint (NULL, TempStr);\r
59febea1
SEHM		 1232 SHELL_FREE_NON_NULL (TempStr);\r
1233\r
1234 for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
1235 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);\r
1d6ccad2
QS		 1236 if (TempStr == NULL) {\r
1237 goto ERROR_EXIT;\r
1238 }\r
5d54bbec 1239 TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
1a6f74d9
CS		 1240 SHELL_FREE_NON_NULL (RetVal);\r
1241 RetVal = TempRetVal;\r
59febea1
SEHM		 1242 SHELL_FREE_NON_NULL (TempStr);\r
1243\r
1244 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
1d6ccad2
QS		 1245 if (TempStr == NULL) {\r
1246 goto ERROR_EXIT;\r
1247 }\r
59febea1
SEHM		 1248\r
1249 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
1a6f74d9
CS		 1250 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
1251 SHELL_FREE_NON_NULL (RetVal);\r
1252 RetVal = TempRetVal;\r
59febea1 1253 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
1a6f74d9
CS		 1254 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
1255 SHELL_FREE_NON_NULL (RetVal);\r
1256 RetVal = TempRetVal;\r
59febea1 1257 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
1a6f74d9
CS		 1258 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
1259 SHELL_FREE_NON_NULL (RetVal);\r
1260 RetVal = TempRetVal;\r
256aa6d0
SEHM		 1261 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {\r
1262 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");\r
1263 SHELL_FREE_NON_NULL (RetVal);\r
1264 RetVal = TempRetVal;\r
59febea1
SEHM		 1265 } else {\r
1266\r
1267 GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
0e88348e
RN		 1268 if (GuidStr == NULL) {\r
1269 TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
1270 SHELL_FREE_NON_NULL (RetVal);\r
1271 RetVal = TempRetVal;\r
1a6f74d9 1272\r
0e88348e
RN		 1273 SHELL_FREE_NON_NULL (TempStr);\r
1274 SHELL_FREE_NON_NULL(GuidStr);\r
1275 //\r
1276 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP\r
1277 //\r
1278 continue;\r
1279 } else {\r
1280 TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
1281 SHELL_FREE_NON_NULL (RetVal);\r
1282 RetVal = TempRetVal;\r
1283 SHELL_FREE_NON_NULL(GuidStr);\r
59febea1
SEHM		 1284 }\r
1285 }\r
1a6f74d9 1286\r
59febea1
SEHM		 1287 SHELL_FREE_NON_NULL (TempStr);\r
1288\r
1289 Status = EfiAdptrInfoProtocol->GetInformation (\r
1290 EfiAdptrInfoProtocol,\r
1291 &InfoTypesBuffer[GuidIndex],\r
1292 &InformationBlock,\r
1293 &InformationBlockSize\r
1294 );\r
1295\r
1296 if (EFI_ERROR (Status)) {\r
1297 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);\r
1d6ccad2
QS		 1298 if (TempStr == NULL) {\r
1299 goto ERROR_EXIT;\r
1300 }\r
1a6f74d9
CS		 1301 TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
1302 SHELL_FREE_NON_NULL (RetVal);\r
1303 RetVal = TempRetVal;\r
59febea1
SEHM		 1304 } else {\r
1305 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
1306 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
1d6ccad2
QS		 1307 if (TempStr == NULL) {\r
1308 goto ERROR_EXIT;\r
1309 }\r
1a6f74d9
CS		 1310 TempRetVal = CatSPrint (\r
1311 RetVal,\r
1312 TempStr,\r
1313 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,\r
1314 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState\r
1315 );\r
1316 SHELL_FREE_NON_NULL (RetVal);\r
1317 RetVal = TempRetVal;\r
59febea1
SEHM		 1318 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
1319 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
1d6ccad2
QS		 1320 if (TempStr == NULL) {\r
1321 goto ERROR_EXIT;\r
1322 }\r
1a6f74d9
CS		 1323 TempRetVal = CatSPrint (\r
1324 RetVal,\r
1325 TempStr,\r
1326 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,\r
1327 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,\r
1328 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,\r
1329 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,\r
1330 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,\r
1331 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,\r
1332 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,\r
1333 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot\r
1334 );\r
1335 SHELL_FREE_NON_NULL (RetVal);\r
1336 RetVal = TempRetVal;\r
1337 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {\r
59febea1 1338 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
1d6ccad2
QS		 1339 if (TempStr == NULL) {\r
1340 goto ERROR_EXIT;\r
1341 }\r
1a6f74d9
CS		 1342 TempRetVal = CatSPrint (\r
1343 RetVal,\r
1344 TempStr,\r
1345 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],\r
1346 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],\r
1347 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],\r
1348 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],\r
1349 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],\r
1350 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]\r
1351 );\r
1352 SHELL_FREE_NON_NULL (RetVal);\r
1353 RetVal = TempRetVal;\r
256aa6d0
SEHM		 1354 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {\r
1355 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNDI_IPV6_INFO), NULL);\r
1356 if (TempStr == NULL) {\r
1357 goto ERROR_EXIT;\r
1358 }\r
1359\r
1360 TempRetVal = CatSPrint (\r
1361 RetVal,\r
1362 TempStr,\r
1363 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support\r
e918029f 1364 );\r
256aa6d0
SEHM		 1365 SHELL_FREE_NON_NULL (RetVal);\r
1366 RetVal = TempRetVal;\r
59febea1
SEHM		 1367 } else {\r
1368 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
1d6ccad2
QS		 1369 if (TempStr == NULL) {\r
1370 goto ERROR_EXIT;\r
1371 }\r
1a6f74d9
CS		 1372 TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
1373 SHELL_FREE_NON_NULL (RetVal);\r
1374 RetVal = TempRetVal;\r
59febea1
SEHM		 1375 }\r
1376 }\r
1377 SHELL_FREE_NON_NULL (TempStr);\r
1378 SHELL_FREE_NON_NULL (InformationBlock);\r
1379 }\r
1380 }\r
1381\r
1d6ccad2 1382 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
59febea1 1383 return RetVal;\r
1d6ccad2
QS		 1384\r
1385ERROR_EXIT:\r
1386 SHELL_FREE_NON_NULL (RetVal);\r
1387 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
1388 SHELL_FREE_NON_NULL (InformationBlock);\r
1389 return NULL;\r
59febea1 1390}\r
8985d612
TS		 1391\r
1392/**\r
1393 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.\r
1394\r
1395 @param[in] TheHandle The handle that has the protocol installed.\r
1396 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
1397\r
1398 @retval A pointer to a string containing the information.\r
1399**/\r
1400CHAR16*\r
1401EFIAPI\r
1402FirmwareManagementDumpInformation (\r
1403 IN CONST EFI_HANDLE TheHandle,\r
1404 IN CONST BOOLEAN Verbose\r
1405 )\r
1406{\r
1407 EFI_STATUS Status;\r
1408 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *EfiFwMgmtProtocol;\r
1409 EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo;\r
1410 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *ImageInfoV1;\r
1411 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *ImageInfoV2;\r
1412 UINT64 AttributeSetting;\r
1413 UINTN ImageInfoSize;\r
1414 UINTN DescriptorSize;\r
1415 UINT32 DescriptorVersion;\r
1416 UINT32 PackageVersion;\r
1417 UINT8 DescriptorCount;\r
1418 UINT8 Index;\r
1419 UINT8 Index1;\r
1420 UINT8 ImageCount;\r
1421 CHAR16 *PackageVersionName;\r
1422 CHAR16 *TempStr;\r
1423 CHAR16 *RetVal;\r
1424 CHAR16 *TempRetVal;\r
1425 CHAR16 *AttributeSettingStr;\r
1426 BOOLEAN Found;\r
1427 BOOLEAN AttributeSupported;\r
1428\r
1429 //\r
1430 // Initialize local variables\r
1431 //\r
1432 ImageCount = 0;\r
1433 ImageInfoSize = 1;\r
1434 AttributeSetting = 0;\r
1435 Found = FALSE;\r
1436 AttributeSupported = FALSE;\r
1437 ImageInfo = NULL;\r
1438 ImageInfoV1 = NULL;\r
1439 ImageInfoV2 = NULL;\r
1440 PackageVersionName = NULL;\r
1441 RetVal = NULL;\r
1442 TempRetVal = NULL;\r
1443 TempStr = NULL;\r
1444 AttributeSettingStr = NULL;\r
1445\r
1446 if (!Verbose) {\r
1447 return (CatSPrint(NULL, L"FirmwareManagement"));\r
1448 }\r
1449\r
1450 Status = gBS->OpenProtocol (\r
1451 (EFI_HANDLE) (TheHandle),\r
1452 &gEfiFirmwareManagementProtocolGuid,\r
1453 (VOID **) &EfiFwMgmtProtocol,\r
1454 NULL,\r
1455 NULL,\r
1456 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1457 );\r
1458\r
1459 if (EFI_ERROR (Status)) {\r
1460 return NULL;\r
1461 }\r
1462\r
1463 Status = EfiFwMgmtProtocol->GetImageInfo (\r
1464 EfiFwMgmtProtocol,\r
1465 &ImageInfoSize,\r
1466 ImageInfo,\r
1467 &DescriptorVersion,\r
1468 &DescriptorCount,\r
1469 &DescriptorSize,\r
1470 &PackageVersion,\r
1471 &PackageVersionName\r
1472 );\r
1473\r
1474 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1475 ImageInfo = AllocateZeroPool (ImageInfoSize);\r
1476\r
1477 if (ImageInfo == NULL) {\r
1478 Status = EFI_OUT_OF_RESOURCES;\r
1479 } else {\r
1480 Status = EfiFwMgmtProtocol->GetImageInfo (\r
1481 EfiFwMgmtProtocol,\r
1482 &ImageInfoSize,\r
1483 ImageInfo,\r
1484 &DescriptorVersion,\r
1485 &DescriptorCount,\r
1486 &DescriptorSize,\r
1487 &PackageVersion,\r
1488 &PackageVersionName\r
1489 );\r
1490 }\r
1491 }\r
1492\r
1493 if (EFI_ERROR (Status)) {\r
1494 goto ERROR_EXIT;\r
1495 }\r
1496\r
1497 //\r
1498 // Decode Image Descriptor data only if its version is supported\r
1499 //\r
1500 if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {\r
1501\r
1502 if (ImageInfo == NULL) {\r
1503 goto ERROR_EXIT;\r
1504 }\r
1505\r
1506 ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;\r
1507 ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;\r
1508\r
1509 //\r
1510 // Set ImageInfoSize in return buffer\r
1511 //\r
1512 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE), NULL);\r
1513 if (TempStr == NULL) {\r
1514 goto ERROR_EXIT;\r
1515 }\r
1516 RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);\r
1517 SHELL_FREE_NON_NULL (TempStr);\r
1518\r
1519 //\r
1520 // Set DescriptorVersion in return buffer\r
1521 //\r
1522 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION), NULL);\r
1523 if (TempStr == NULL) {\r
1524 goto ERROR_EXIT;\r
1525 }\r
1526 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);\r
1527 SHELL_FREE_NON_NULL (RetVal);\r
1528 RetVal = TempRetVal;\r
1529 SHELL_FREE_NON_NULL (TempStr);\r
1530\r
1531 //\r
1532 // Set DescriptorCount in return buffer\r
1533 //\r
1534 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT), NULL);\r
1535 if (TempStr == NULL) {\r
1536 goto ERROR_EXIT;\r
1537 }\r
1538 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);\r
1539 SHELL_FREE_NON_NULL (RetVal);\r
1540 RetVal = TempRetVal;\r
1541 SHELL_FREE_NON_NULL (TempStr);\r
1542\r
1543\r
1544 //\r
1545 // Set DescriptorSize in return buffer\r
1546 //\r
1547 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE), NULL);\r
1548 if (TempStr == NULL) {\r
1549 goto ERROR_EXIT;\r
1550 }\r
1551 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);\r
1552 SHELL_FREE_NON_NULL (RetVal);\r
1553 RetVal = TempRetVal;\r
1554 SHELL_FREE_NON_NULL (TempStr);\r
1555\r
1556 //\r
1557 // Set PackageVersion in return buffer\r
1558 //\r
1559 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION), NULL);\r
1560 if (TempStr == NULL) {\r
1561 goto ERROR_EXIT;\r
1562 }\r
1563 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);\r
1564 SHELL_FREE_NON_NULL (RetVal);\r
1565 RetVal = TempRetVal;\r
1566 SHELL_FREE_NON_NULL (TempStr);\r
1567\r
1568 //\r
1569 // Set PackageVersionName in return buffer\r
1570 //\r
1571 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME), NULL);\r
1572 if (TempStr == NULL) {\r
1573 goto ERROR_EXIT;\r
1574 }\r
1575 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);\r
1576 SHELL_FREE_NON_NULL (RetVal);\r
1577 RetVal = TempRetVal;\r
1578 SHELL_FREE_NON_NULL (TempStr);\r
1579\r
1580 for (Index = 0; Index < DescriptorCount; Index++) {\r
1581 //\r
1582 // First check if Attribute is supported\r
1583 // and generate a string for AttributeSetting field\r
1584 //\r
1585 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1586 AttributeSupported = FALSE;\r
1587 AttributeSetting = 0;\r
1588 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1589 if (ImageInfoV1[Index].AttributesSupported != 0x0) {\r
1590 AttributeSupported = TRUE;\r
1591 AttributeSetting = ImageInfoV1[Index].AttributesSetting;\r
1592 }\r
1593 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1594 if (ImageInfoV2[Index].AttributesSupported != 0x0) {\r
1595 AttributeSupported = TRUE;\r
1596 AttributeSetting = ImageInfoV2[Index].AttributesSetting;\r
1597 }\r
1598 } else {\r
1599 if (ImageInfo[Index].AttributesSupported != 0x0) {\r
1600 AttributeSupported = TRUE;\r
1601 AttributeSetting = ImageInfo[Index].AttributesSetting;\r
1602 }\r
1603 }\r
1604\r
1605 if (!AttributeSupported) {\r
1606 AttributeSettingStr = CatSPrint (NULL, L"None");\r
1607 } else {\r
1608 AttributeSettingStr = CatSPrint (NULL, L"(");\r
1609\r
ac14846a 1610 if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
8985d612
TS		 1611 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
1612 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1613 AttributeSettingStr = TempRetVal;\r
1614 }\r
ac14846a 1615 if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
8985d612
TS		 1616 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
1617 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1618 AttributeSettingStr = TempRetVal;\r
1619 }\r
ac14846a 1620 if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
8985d612
TS		 1621 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
1622 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1623 AttributeSettingStr = TempRetVal;\r
1624 }\r
ac14846a 1625 if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
8985d612
TS		 1626 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
1627 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1628 AttributeSettingStr = TempRetVal;\r
1629 }\r
ac14846a 1630 if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
8985d612
TS		 1631 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");\r
1632 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1633 AttributeSettingStr = TempRetVal;\r
1634 }\r
1635 TempRetVal = CatSPrint (AttributeSettingStr, L" )");\r
1636 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1637 AttributeSettingStr = TempRetVal;\r
1638 }\r
1639\r
1640 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1641 if (ImageInfoV1[Index].ImageIndex != 0x0) {\r
1642 ImageCount++;\r
1643 }\r
1644\r
1645 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);\r
1646 if (TempStr == NULL) {\r
1647 goto ERROR_EXIT;\r
1648 }\r
1649 TempRetVal = CatSPrint (\r
1650 RetVal,\r
1651 TempStr,\r
1652 Index,\r
1653 ImageInfoV1[Index].ImageIndex,\r
e06a4c08 1654 &ImageInfoV1[Index].ImageTypeId,\r
8985d612
TS		 1655 ImageInfoV1[Index].ImageId,\r
1656 ImageInfoV1[Index].ImageIdName,\r
1657 ImageInfoV1[Index].Version,\r
1658 ImageInfoV1[Index].VersionName,\r
1659 ImageInfoV1[Index].Size,\r
1660 ImageInfoV1[Index].AttributesSupported,\r
1661 AttributeSettingStr,\r
1662 ImageInfoV1[Index].Compatibilities\r
1663 );\r
1664 SHELL_FREE_NON_NULL (RetVal);\r
1665 RetVal = TempRetVal;\r
1666 SHELL_FREE_NON_NULL (TempStr);\r
1667 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1668 if (ImageInfoV2[Index].ImageIndex != 0x0) {\r
1669 ImageCount++;\r
1670 }\r
1671\r
1672 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);\r
1673 if (TempStr == NULL) {\r
1674 goto ERROR_EXIT;\r
1675 }\r
1676 TempRetVal = CatSPrint (\r
1677 RetVal,\r
1678 TempStr,\r
1679 Index,\r
1680 ImageInfoV2[Index].ImageIndex,\r
e06a4c08 1681 &ImageInfoV2[Index].ImageTypeId,\r
8985d612
TS		 1682 ImageInfoV2[Index].ImageId,\r
1683 ImageInfoV2[Index].ImageIdName,\r
1684 ImageInfoV2[Index].Version,\r
1685 ImageInfoV2[Index].VersionName,\r
1686 ImageInfoV2[Index].Size,\r
1687 ImageInfoV2[Index].AttributesSupported,\r
1688 AttributeSettingStr,\r
1689 ImageInfoV2[Index].Compatibilities,\r
1690 ImageInfoV2[Index].LowestSupportedImageVersion\r
1691 );\r
1692 SHELL_FREE_NON_NULL (RetVal);\r
1693 RetVal = TempRetVal;\r
1694 SHELL_FREE_NON_NULL (TempStr);\r
1695 } else {\r
1696 if (ImageInfo[Index].ImageIndex != 0x0) {\r
1697 ImageCount++;\r
1698 }\r
1699\r
1700 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);\r
1701 if (TempStr == NULL) {\r
1702 goto ERROR_EXIT;\r
1703 }\r
1704 TempRetVal = CatSPrint (\r
1705 RetVal,\r
1706 TempStr,\r
1707 Index,\r
1708 ImageInfo[Index].ImageIndex,\r
e06a4c08 1709 &ImageInfo[Index].ImageTypeId,\r
8985d612
TS		 1710 ImageInfo[Index].ImageId,\r
1711 ImageInfo[Index].ImageIdName,\r
1712 ImageInfo[Index].Version,\r
1713 ImageInfo[Index].VersionName,\r
1714 ImageInfo[Index].Size,\r
1715 ImageInfo[Index].AttributesSupported,\r
1716 AttributeSettingStr,\r
1717 ImageInfo[Index].Compatibilities,\r
1718 ImageInfo[Index].LowestSupportedImageVersion,\r
1719 ImageInfo[Index].LastAttemptVersion,\r
1720 ImageInfo[Index].LastAttemptStatus,\r
1721 ImageInfo[Index].HardwareInstance\r
1722 );\r
1723 SHELL_FREE_NON_NULL (RetVal);\r
1724 RetVal = TempRetVal;\r
1725 SHELL_FREE_NON_NULL (TempStr);\r
1726 }\r
1727 }\r
1728 }\r
1729\r
1730 if (ImageCount > 0) {\r
1731 for (Index=0; Index<DescriptorCount; Index++) {\r
1732 for (Index1=Index+1; Index1<DescriptorCount; Index1++) {\r
1733 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1734 if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {\r
1735 Found = TRUE;\r
1736 //\r
1737 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1738 //\r
1739 goto ENDLOOP;\r
1740 }\r
1741 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1742 if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {\r
1743 Found = TRUE;\r
1744 //\r
1745 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1746 //\r
1747 goto ENDLOOP;\r
1748 }\r
1749 } else {\r
1750 if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {\r
1751 Found = TRUE;\r
1752 //\r
1753 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1754 //\r
1755 goto ENDLOOP;\r
1756 }\r
1757 }\r
1758 }\r
1759 }\r
1760 }\r
1761\r
1762ENDLOOP:\r
1763 //\r
1764 // Check if ImageId with duplicate value was found\r
1765 //\r
ac14846a 1766 if (Found) {\r
8985d612
TS		 1767 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE), NULL);\r
1768 if (TempStr == NULL) {\r
1769 goto ERROR_EXIT;\r
1770 }\r
1771 TempRetVal = CatSPrint (RetVal, TempStr);\r
1772 SHELL_FREE_NON_NULL (RetVal);\r
1773 RetVal = TempRetVal;\r
1774 SHELL_FREE_NON_NULL (TempStr);\r
1775 }\r
1776\r
1777 SHELL_FREE_NON_NULL (ImageInfo);\r
1778 SHELL_FREE_NON_NULL (PackageVersionName);\r
1779 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1780\r
1781 return RetVal;\r
1782\r
1783ERROR_EXIT:\r
1784 SHELL_FREE_NON_NULL (RetVal);\r
1785 SHELL_FREE_NON_NULL (ImageInfo);\r
1786 SHELL_FREE_NON_NULL (PackageVersionName);\r
1787 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1788\r
1789 return NULL;\r
1790}\r
1791\r
a405b86d 1792//\r
1793// Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg\r
1794//\r
1795#define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \\r
1796 { \\r
ce68d3bc 1797 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1798 }\r
1799\r
1800#define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \\r
1801 { \\r
ce68d3bc 1802 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1803 }\r
1804\r
1805#define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \\r
1806 { \\r
ce68d3bc 1807 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1808 }\r
1809STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;\r
1810STATIC CONST EFI_GUID WinNtIoProtocolGuid = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;\r
1811STATIC CONST EFI_GUID WinNtSerialPortGuid = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;\r
1812\r
2c23ddaa 1813//\r
1814// Deprecated protocols we dont want to link from IntelFrameworkModulePkg\r
1815//\r
1816#define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \\r
1817 { \\r
1818 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \\r
1a6f74d9 1819 }\r
2c23ddaa 1820#define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \\r
1821 { \\r
1822 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \\r
1823 }\r
1824STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;\r
1825STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;\r
1826\r
1827\r
dee34318 1828STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {\r
a405b86d 1829 {STRING_TOKEN(STR_WINNT_THUNK), (EFI_GUID*)&WinNtThunkProtocolGuid, NULL},\r
1830 {STRING_TOKEN(STR_WINNT_DRIVER_IO), (EFI_GUID*)&WinNtIoProtocolGuid, NULL},\r
1831 {STRING_TOKEN(STR_WINNT_SERIAL_PORT), (EFI_GUID*)&WinNtSerialPortGuid, NULL},\r
0e88348e 1832 {0, NULL, NULL},\r
a405b86d 1833};\r
1834\r
dee34318 1835STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
efb76d1a 1836 {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation},\r
a405b86d 1837 {STRING_TOKEN(STR_DEVICE_PATH), &gEfiDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
5e32460d 1838 {STRING_TOKEN(STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, LoadedImageDevicePathProtocolDumpInformation},\r
a405b86d 1839 {STRING_TOKEN(STR_DEVICE_PATH_UTIL), &gEfiDevicePathUtilitiesProtocolGuid, NULL},\r
1840 {STRING_TOKEN(STR_DEVICE_PATH_TXT), &gEfiDevicePathToTextProtocolGuid, NULL},\r
1841 {STRING_TOKEN(STR_DEVICE_PATH_FTXT), &gEfiDevicePathFromTextProtocolGuid, NULL},\r
1842 {STRING_TOKEN(STR_DEVICE_PATH_PC), &gEfiPcAnsiGuid, NULL},\r
1843 {STRING_TOKEN(STR_DEVICE_PATH_VT100), &gEfiVT100Guid, NULL},\r
1844 {STRING_TOKEN(STR_DEVICE_PATH_VT100P), &gEfiVT100PlusGuid, NULL},\r
1845 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8), &gEfiVTUTF8Guid, NULL},\r
1846 {STRING_TOKEN(STR_DRIVER_BINDING), &gEfiDriverBindingProtocolGuid, NULL},\r
1847 {STRING_TOKEN(STR_PLATFORM_OVERRIDE), &gEfiPlatformDriverOverrideProtocolGuid, NULL},\r
d772f5f3 1848 {STRING_TOKEN(STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, BusSpecificDriverOverrideProtocolDumpInformation},\r
a405b86d 1849 {STRING_TOKEN(STR_DRIVER_DIAG), &gEfiDriverDiagnosticsProtocolGuid, NULL},\r
1850 {STRING_TOKEN(STR_DRIVER_DIAG2), &gEfiDriverDiagnostics2ProtocolGuid, NULL},\r
1851 {STRING_TOKEN(STR_DRIVER_CN), &gEfiComponentNameProtocolGuid, NULL},\r
1852 {STRING_TOKEN(STR_DRIVER_CN2), &gEfiComponentName2ProtocolGuid, NULL},\r
1853 {STRING_TOKEN(STR_PLAT_DRV_CFG), &gEfiPlatformToDriverConfigurationProtocolGuid, NULL},\r
1854 {STRING_TOKEN(STR_DRIVER_VERSION), &gEfiDriverSupportedEfiVersionProtocolGuid, DriverEfiVersionProtocolDumpInformation},\r
1855 {STRING_TOKEN(STR_TXT_IN), &gEfiSimpleTextInProtocolGuid, NULL},\r
1856 {STRING_TOKEN(STR_TXT_IN_EX), &gEfiSimpleTextInputExProtocolGuid, NULL},\r
1857 {STRING_TOKEN(STR_TXT_OUT), &gEfiSimpleTextOutProtocolGuid, TxtOutProtocolDumpInformation},\r
1858 {STRING_TOKEN(STR_SIM_POINTER), &gEfiSimplePointerProtocolGuid, NULL},\r
1859 {STRING_TOKEN(STR_ABS_POINTER), &gEfiAbsolutePointerProtocolGuid, NULL},\r
1860 {STRING_TOKEN(STR_SERIAL_IO), &gEfiSerialIoProtocolGuid, NULL},\r
609e0c58 1861 {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation},\r
e918029f
RN		 1862 {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, EdidDiscoveredProtocolDumpInformation},\r
1863 {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, EdidActiveProtocolDumpInformation},\r
a405b86d 1864 {STRING_TOKEN(STR_EDID_OVERRIDE), &gEfiEdidOverrideProtocolGuid, NULL},\r
1865 {STRING_TOKEN(STR_CON_IN), &gEfiConsoleInDeviceGuid, NULL},\r
1866 {STRING_TOKEN(STR_CON_OUT), &gEfiConsoleOutDeviceGuid, NULL},\r
1867 {STRING_TOKEN(STR_STD_ERR), &gEfiStandardErrorDeviceGuid, NULL},\r
1868 {STRING_TOKEN(STR_LOAD_FILE), &gEfiLoadFileProtocolGuid, NULL},\r
1869 {STRING_TOKEN(STR_LOAD_FILE2), &gEfiLoadFile2ProtocolGuid, NULL},\r
1870 {STRING_TOKEN(STR_SIMPLE_FILE_SYS), &gEfiSimpleFileSystemProtocolGuid, NULL},\r
a405b86d 1871 {STRING_TOKEN(STR_TAPE_IO), &gEfiTapeIoProtocolGuid, NULL},\r
1872 {STRING_TOKEN(STR_DISK_IO), &gEfiDiskIoProtocolGuid, NULL},\r
24ac68ef 1873 {STRING_TOKEN(STR_BLK_IO), &gEfiBlockIoProtocolGuid, BlockIoProtocolDumpInformation},\r
a405b86d 1874 {STRING_TOKEN(STR_UC), &gEfiUnicodeCollationProtocolGuid, NULL},\r
1875 {STRING_TOKEN(STR_UC2), &gEfiUnicodeCollation2ProtocolGuid, NULL},\r
f4f3c6bf 1876 {STRING_TOKEN(STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation},\r
a405b86d 1877 {STRING_TOKEN(STR_PCI_IO), &gEfiPciIoProtocolGuid, NULL},\r
1878 {STRING_TOKEN(STR_SCSI_PT), &gEfiScsiPassThruProtocolGuid, NULL},\r
1879 {STRING_TOKEN(STR_SCSI_IO), &gEfiScsiIoProtocolGuid, NULL},\r
1880 {STRING_TOKEN(STR_SCSI_PT_EXT), &gEfiExtScsiPassThruProtocolGuid, NULL},\r
1881 {STRING_TOKEN(STR_ISCSI), &gEfiIScsiInitiatorNameProtocolGuid, NULL},\r
1882 {STRING_TOKEN(STR_USB_IO), &gEfiUsbIoProtocolGuid, NULL},\r
1883 {STRING_TOKEN(STR_USB_HC), &gEfiUsbHcProtocolGuid, NULL},\r
1884 {STRING_TOKEN(STR_USB_HC2), &gEfiUsb2HcProtocolGuid, NULL},\r
6fcf7288 1885 {STRING_TOKEN(STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, DebugSupportProtocolDumpInformation},\r
a405b86d 1886 {STRING_TOKEN(STR_DEBUG_PORT), &gEfiDebugPortProtocolGuid, NULL},\r
1887 {STRING_TOKEN(STR_DECOMPRESS), &gEfiDecompressProtocolGuid, NULL},\r
1888 {STRING_TOKEN(STR_ACPI_TABLE), &gEfiAcpiTableProtocolGuid, NULL},\r
1889 {STRING_TOKEN(STR_EBC_INTERPRETER), &gEfiEbcProtocolGuid, NULL},\r
1890 {STRING_TOKEN(STR_SNP), &gEfiSimpleNetworkProtocolGuid, NULL},\r
1891 {STRING_TOKEN(STR_NII), &gEfiNetworkInterfaceIdentifierProtocolGuid, NULL},\r
1892 {STRING_TOKEN(STR_NII_31), &gEfiNetworkInterfaceIdentifierProtocolGuid_31, NULL},\r
1893 {STRING_TOKEN(STR_PXE_BC), &gEfiPxeBaseCodeProtocolGuid, NULL},\r
1894 {STRING_TOKEN(STR_PXE_CB), &gEfiPxeBaseCodeCallbackProtocolGuid, NULL},\r
1895 {STRING_TOKEN(STR_BIS), &gEfiBisProtocolGuid, NULL},\r
1896 {STRING_TOKEN(STR_MNP_SB), &gEfiManagedNetworkServiceBindingProtocolGuid, NULL},\r
1897 {STRING_TOKEN(STR_MNP), &gEfiManagedNetworkProtocolGuid, NULL},\r
1898 {STRING_TOKEN(STR_ARP_SB), &gEfiArpServiceBindingProtocolGuid, NULL},\r
1899 {STRING_TOKEN(STR_ARP), &gEfiArpProtocolGuid, NULL},\r
1900 {STRING_TOKEN(STR_DHCPV4_SB), &gEfiDhcp4ServiceBindingProtocolGuid, NULL},\r
1901 {STRING_TOKEN(STR_DHCPV4), &gEfiDhcp4ProtocolGuid, NULL},\r
1902 {STRING_TOKEN(STR_TCPV4_SB), &gEfiTcp4ServiceBindingProtocolGuid, NULL},\r
1903 {STRING_TOKEN(STR_TCPV4), &gEfiTcp4ProtocolGuid, NULL},\r
1904 {STRING_TOKEN(STR_IPV4_SB), &gEfiIp4ServiceBindingProtocolGuid, NULL},\r
1905 {STRING_TOKEN(STR_IPV4), &gEfiIp4ProtocolGuid, NULL},\r
1906 {STRING_TOKEN(STR_IPV4_CFG), &gEfiIp4ConfigProtocolGuid, NULL},\r
00a6ad1b 1907 {STRING_TOKEN(STR_IPV4_CFG2), &gEfiIp4Config2ProtocolGuid, NULL},\r
a405b86d 1908 {STRING_TOKEN(STR_UDPV4_SB), &gEfiUdp4ServiceBindingProtocolGuid, NULL},\r
1909 {STRING_TOKEN(STR_UDPV4), &gEfiUdp4ProtocolGuid, NULL},\r
1910 {STRING_TOKEN(STR_MTFTPV4_SB), &gEfiMtftp4ServiceBindingProtocolGuid, NULL},\r
1911 {STRING_TOKEN(STR_MTFTPV4), &gEfiMtftp4ProtocolGuid, NULL},\r
1912 {STRING_TOKEN(STR_AUTH_INFO), &gEfiAuthenticationInfoProtocolGuid, NULL},\r
1913 {STRING_TOKEN(STR_HASH_SB), &gEfiHashServiceBindingProtocolGuid, NULL},\r
1914 {STRING_TOKEN(STR_HASH), &gEfiHashProtocolGuid, NULL},\r
1915 {STRING_TOKEN(STR_HII_FONT), &gEfiHiiFontProtocolGuid, NULL},\r
1916 {STRING_TOKEN(STR_HII_STRING), &gEfiHiiStringProtocolGuid, NULL},\r
1917 {STRING_TOKEN(STR_HII_IMAGE), &gEfiHiiImageProtocolGuid, NULL},\r
1918 {STRING_TOKEN(STR_HII_DATABASE), &gEfiHiiDatabaseProtocolGuid, NULL},\r
1919 {STRING_TOKEN(STR_HII_CONFIG_ROUT), &gEfiHiiConfigRoutingProtocolGuid, NULL},\r
1920 {STRING_TOKEN(STR_HII_CONFIG_ACC), &gEfiHiiConfigAccessProtocolGuid, NULL},\r
1921 {STRING_TOKEN(STR_HII_FORM_BROWSER2), &gEfiFormBrowser2ProtocolGuid, NULL},\r
dee34318 1922 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE), &gEfiDriverFamilyOverrideProtocolGuid, NULL},\r
1923 {STRING_TOKEN(STR_PCD), &gPcdProtocolGuid, NULL},\r
1924 {STRING_TOKEN(STR_TCG), &gEfiTcgProtocolGuid, NULL},\r
1925 {STRING_TOKEN(STR_HII_PACKAGE_LIST), &gEfiHiiPackageListProtocolGuid, NULL},\r
1926\r
1927//\r
1928// the ones under this are deprecated by the current UEFI Spec, but may be found anyways...\r
1929//\r
a405b86d 1930 {STRING_TOKEN(STR_SHELL_INTERFACE), &gEfiShellInterfaceGuid, NULL},\r
1931 {STRING_TOKEN(STR_SHELL_ENV2), &gEfiShellEnvironment2Guid, NULL},\r
1932 {STRING_TOKEN(STR_SHELL_ENV), &gEfiShellEnvironment2Guid, NULL},\r
1933 {STRING_TOKEN(STR_DEVICE_IO), &gEfiDeviceIoProtocolGuid, NULL},\r
1934 {STRING_TOKEN(STR_UGA_DRAW), &gEfiUgaDrawProtocolGuid, NULL},\r
1935 {STRING_TOKEN(STR_UGA_IO), &gEfiUgaIoProtocolGuid, NULL},\r
1936 {STRING_TOKEN(STR_ESP), &gEfiPartTypeSystemPartGuid, NULL},\r
1937 {STRING_TOKEN(STR_GPT_NBR), &gEfiPartTypeLegacyMbrGuid, NULL},\r
1938 {STRING_TOKEN(STR_DRIVER_CONFIG), &gEfiDriverConfigurationProtocolGuid, NULL},\r
1939 {STRING_TOKEN(STR_DRIVER_CONFIG2), &gEfiDriverConfiguration2ProtocolGuid, NULL},\r
2c23ddaa 1940\r
1941//\r
1942// these are using local (non-global) definitions to reduce package dependancy.\r
1943//\r
1944 {STRING_TOKEN(STR_ISA_IO), (EFI_GUID*)&EfiIsaIoProtocolGuid, NULL},\r
1945 {STRING_TOKEN(STR_ISA_ACPI), (EFI_GUID*)&EfiIsaAcpiProtocolGuid, NULL},\r
dee34318 1946\r
1947//\r
1948// the ones under this are GUID identified structs, not protocols\r
1949//\r
1950 {STRING_TOKEN(STR_FILE_INFO), &gEfiFileInfoGuid, NULL},\r
1951 {STRING_TOKEN(STR_FILE_SYS_INFO), &gEfiFileSystemInfoGuid, NULL},\r
1952\r
1953//\r
1954// the ones under this are misc GUIDS.\r
1955//\r
1956 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE), &gEfiGlobalVariableGuid, NULL},\r
1957\r
1958//\r
1959// UEFI 2.2\r
1960//\r
1961 {STRING_TOKEN(STR_IP6_SB), &gEfiIp6ServiceBindingProtocolGuid, NULL},\r
1962 {STRING_TOKEN(STR_IP6), &gEfiIp6ProtocolGuid, NULL},\r
1963 {STRING_TOKEN(STR_IP6_CONFIG), &gEfiIp6ConfigProtocolGuid, NULL},\r
1964 {STRING_TOKEN(STR_MTFTP6_SB), &gEfiMtftp6ServiceBindingProtocolGuid, NULL},\r
1965 {STRING_TOKEN(STR_MTFTP6), &gEfiMtftp6ProtocolGuid, NULL},\r
1966 {STRING_TOKEN(STR_DHCP6_SB), &gEfiDhcp6ServiceBindingProtocolGuid, NULL},\r
1967 {STRING_TOKEN(STR_DHCP6), &gEfiDhcp6ProtocolGuid, NULL},\r
1968 {STRING_TOKEN(STR_UDP6_SB), &gEfiUdp6ServiceBindingProtocolGuid, NULL},\r
1969 {STRING_TOKEN(STR_UDP6), &gEfiUdp6ProtocolGuid, NULL},\r
1970 {STRING_TOKEN(STR_TCP6_SB), &gEfiTcp6ServiceBindingProtocolGuid, NULL},\r
1971 {STRING_TOKEN(STR_TCP6), &gEfiTcp6ProtocolGuid, NULL},\r
1972 {STRING_TOKEN(STR_VLAN_CONFIG), &gEfiVlanConfigProtocolGuid, NULL},\r
1973 {STRING_TOKEN(STR_EAP), &gEfiEapProtocolGuid, NULL},\r
1974 {STRING_TOKEN(STR_EAP_MGMT), &gEfiEapManagementProtocolGuid, NULL},\r
1975 {STRING_TOKEN(STR_FTP4_SB), &gEfiFtp4ServiceBindingProtocolGuid, NULL},\r
1976 {STRING_TOKEN(STR_FTP4), &gEfiFtp4ProtocolGuid, NULL},\r
1977 {STRING_TOKEN(STR_IP_SEC_CONFIG), &gEfiIpSecConfigProtocolGuid, NULL},\r
1978 {STRING_TOKEN(STR_DH), &gEfiDriverHealthProtocolGuid, NULL},\r
1979 {STRING_TOKEN(STR_DEF_IMG_LOAD), &gEfiDeferredImageLoadProtocolGuid, NULL},\r
1980 {STRING_TOKEN(STR_USER_CRED), &gEfiUserCredentialProtocolGuid, NULL},\r
1981 {STRING_TOKEN(STR_USER_MNGR), &gEfiUserManagerProtocolGuid, NULL},\r
1982 {STRING_TOKEN(STR_ATA_PASS_THRU), &gEfiAtaPassThruProtocolGuid, NULL},\r
1983\r
1984//\r
1985// UEFI 2.3\r
1986//\r
8985d612 1987 {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, FirmwareManagementDumpInformation},\r
dee34318 1988 {STRING_TOKEN(STR_IP_SEC), &gEfiIpSecProtocolGuid, NULL},\r
1989 {STRING_TOKEN(STR_IP_SEC2), &gEfiIpSec2ProtocolGuid, NULL},\r
1990\r
1991//\r
1992// UEFI 2.3.1\r
1993//\r
1994 {STRING_TOKEN(STR_KMS), &gEfiKmsProtocolGuid, NULL},\r
1995 {STRING_TOKEN(STR_BLK_IO2), &gEfiBlockIo2ProtocolGuid, NULL},\r
1996 {STRING_TOKEN(STR_SSC), &gEfiStorageSecurityCommandProtocolGuid, NULL},\r
12f1a36c 1997 {STRING_TOKEN(STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL},\r
dee34318 1998\r
28cdb62b
CP		 1999//\r
2000// UEFI 2.4\r
2001//\r
2002 {STRING_TOKEN(STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL},\r
59febea1 2003 {STRING_TOKEN(STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, AdapterInformationDumpInformation},\r
28cdb62b 2004\r
6b640b4a
JC		 2005//\r
2006// PI Spec ones\r
2007//\r
2008 {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
4024c116 2009 {STRING_TOKEN(STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL},\r
6b640b4a 2010\r
c2788f1c
JC		 2011//\r
2012// PI Spec 1.0\r
2013//\r
2014 {STRING_TOKEN(STR_BDS_ARCH), &gEfiBdsArchProtocolGuid, NULL},\r
2015 {STRING_TOKEN(STR_CPU_ARCH), &gEfiCpuArchProtocolGuid, NULL},\r
2016 {STRING_TOKEN(STR_MET_ARCH), &gEfiMetronomeArchProtocolGuid, NULL},\r
2017 {STRING_TOKEN(STR_MON_ARCH), &gEfiMonotonicCounterArchProtocolGuid, NULL},\r
2018 {STRING_TOKEN(STR_RTC_ARCH), &gEfiRealTimeClockArchProtocolGuid, NULL},\r
2019 {STRING_TOKEN(STR_RESET_ARCH), &gEfiResetArchProtocolGuid, NULL},\r
2020 {STRING_TOKEN(STR_RT_ARCH), &gEfiRuntimeArchProtocolGuid, NULL},\r
2021 {STRING_TOKEN(STR_SEC_ARCH), &gEfiSecurityArchProtocolGuid, NULL},\r
2022 {STRING_TOKEN(STR_TIMER_ARCH), &gEfiTimerArchProtocolGuid, NULL},\r
2023 {STRING_TOKEN(STR_VAR_ARCH), &gEfiVariableWriteArchProtocolGuid, NULL},\r
2024 {STRING_TOKEN(STR_V_ARCH), &gEfiVariableArchProtocolGuid, NULL},\r
2025 {STRING_TOKEN(STR_SECP), &gEfiSecurityPolicyProtocolGuid, NULL},\r
2026 {STRING_TOKEN(STR_WDT_ARCH), &gEfiWatchdogTimerArchProtocolGuid, NULL},\r
2027 {STRING_TOKEN(STR_SCR), &gEfiStatusCodeRuntimeProtocolGuid, NULL},\r
2028 {STRING_TOKEN(STR_SMB_HC), &gEfiSmbusHcProtocolGuid, NULL},\r
2029 {STRING_TOKEN(STR_FV_2), &gEfiFirmwareVolume2ProtocolGuid, NULL},\r
2030 {STRING_TOKEN(STR_FV_BLOCK), &gEfiFirmwareVolumeBlockProtocolGuid, NULL},\r
2031 {STRING_TOKEN(STR_CAP_ARCH), &gEfiCapsuleArchProtocolGuid, NULL},\r
2032 {STRING_TOKEN(STR_MP_SERVICE), &gEfiMpServiceProtocolGuid, NULL},\r
2033 {STRING_TOKEN(STR_HBRAP), &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},\r
2034 {STRING_TOKEN(STR_PCIP), &gEfiPciPlatformProtocolGuid, NULL},\r
2035 {STRING_TOKEN(STR_PCIO), &gEfiPciOverrideProtocolGuid, NULL},\r
2036 {STRING_TOKEN(STR_PCIE), &gEfiPciEnumerationCompleteProtocolGuid, NULL},\r
2037 {STRING_TOKEN(STR_IPCID), &gEfiIncompatiblePciDeviceSupportProtocolGuid, NULL},\r
2038 {STRING_TOKEN(STR_PCIHPI), &gEfiPciHotPlugInitProtocolGuid, NULL},\r
2039 {STRING_TOKEN(STR_PCIHPR), &gEfiPciHotPlugRequestProtocolGuid, NULL},\r
2040 {STRING_TOKEN(STR_SMBIOS), &gEfiSmbiosProtocolGuid, NULL},\r
2041 {STRING_TOKEN(STR_S3_SAVE), &gEfiS3SaveStateProtocolGuid, NULL},\r
2042 {STRING_TOKEN(STR_S3_S_SMM), &gEfiS3SmmSaveStateProtocolGuid, NULL},\r
2043 {STRING_TOKEN(STR_RSC), &gEfiRscHandlerProtocolGuid, NULL},\r
2044 {STRING_TOKEN(STR_S_RSC), &gEfiSmmRscHandlerProtocolGuid, NULL},\r
2045 {STRING_TOKEN(STR_ACPI_SDT), &gEfiAcpiSdtProtocolGuid, NULL},\r
2046 {STRING_TOKEN(STR_SIO), &gEfiSioProtocolGuid, NULL},\r
2047 {STRING_TOKEN(STR_S_CPU2), &gEfiSmmCpuIo2ProtocolGuid, NULL},\r
2048 {STRING_TOKEN(STR_S_BASE2), &gEfiSmmBase2ProtocolGuid, NULL},\r
2049 {STRING_TOKEN(STR_S_ACC_2), &gEfiSmmAccess2ProtocolGuid, NULL},\r
2050 {STRING_TOKEN(STR_S_CON_2), &gEfiSmmControl2ProtocolGuid, NULL},\r
2051 {STRING_TOKEN(STR_S_CONFIG), &gEfiSmmConfigurationProtocolGuid, NULL},\r
2052 {STRING_TOKEN(STR_S_RTL), &gEfiSmmReadyToLockProtocolGuid, NULL},\r
2053 {STRING_TOKEN(STR_DS_RTL), &gEfiDxeSmmReadyToLockProtocolGuid, NULL},\r
2054 {STRING_TOKEN(STR_S_COMM), &gEfiSmmCommunicationProtocolGuid, NULL},\r
2055 {STRING_TOKEN(STR_S_STAT), &gEfiSmmStatusCodeProtocolGuid, NULL},\r
2056 {STRING_TOKEN(STR_S_CPU), &gEfiSmmCpuProtocolGuid, NULL},\r
2057 {STRING_TOKEN(STR_S_PCIRBIO), &gEfiPciRootBridgeIoProtocolGuid, NULL},\r
2058 {STRING_TOKEN(STR_S_SWD), &gEfiSmmSwDispatch2ProtocolGuid, NULL},\r
2059 {STRING_TOKEN(STR_S_SXD), &gEfiSmmSxDispatch2ProtocolGuid, NULL},\r
2060 {STRING_TOKEN(STR_S_PTD2), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid, NULL},\r
2061 {STRING_TOKEN(STR_S_UD2), &gEfiSmmUsbDispatch2ProtocolGuid, NULL},\r
2062 {STRING_TOKEN(STR_S_GD2), &gEfiSmmGpiDispatch2ProtocolGuid, NULL},\r
2063 {STRING_TOKEN(STR_S_SBD2), &gEfiSmmStandbyButtonDispatch2ProtocolGuid, NULL},\r
2064 {STRING_TOKEN(STR_S_PBD2), &gEfiSmmPowerButtonDispatch2ProtocolGuid, NULL},\r
2065 {STRING_TOKEN(STR_S_ITD2), &gEfiSmmIoTrapDispatch2ProtocolGuid, NULL},\r
2066 {STRING_TOKEN(STR_PCD), &gEfiPcdProtocolGuid, NULL},\r
2067 {STRING_TOKEN(STR_FVB2), &gEfiFirmwareVolumeBlock2ProtocolGuid, NULL},\r
2068 {STRING_TOKEN(STR_CPUIO2), &gEfiCpuIo2ProtocolGuid, NULL},\r
2069 {STRING_TOKEN(STR_LEGACY_R2), &gEfiLegacyRegion2ProtocolGuid, NULL},\r
2070 {STRING_TOKEN(STR_SAL_MIP), &gEfiSalMcaInitPmiProtocolGuid, NULL},\r
2071 {STRING_TOKEN(STR_ES_BS), &gEfiExtendedSalBootServiceProtocolGuid, NULL},\r
2072 {STRING_TOKEN(STR_ES_BIO), &gEfiExtendedSalBaseIoServicesProtocolGuid, NULL},\r
2073 {STRING_TOKEN(STR_ES_STALL), &gEfiExtendedSalStallServicesProtocolGuid, NULL},\r
2074 {STRING_TOKEN(STR_ES_RTC), &gEfiExtendedSalRtcServicesProtocolGuid, NULL},\r
2075 {STRING_TOKEN(STR_ES_VS), &gEfiExtendedSalVariableServicesProtocolGuid, NULL},\r
2076 {STRING_TOKEN(STR_ES_MTC), &gEfiExtendedSalMtcServicesProtocolGuid, NULL},\r
2077 {STRING_TOKEN(STR_ES_RESET), &gEfiExtendedSalResetServicesProtocolGuid, NULL},\r
2078 {STRING_TOKEN(STR_ES_SC), &gEfiExtendedSalStatusCodeServicesProtocolGuid, NULL},\r
2079 {STRING_TOKEN(STR_ES_FBS), &gEfiExtendedSalFvBlockServicesProtocolGuid, NULL},\r
2080 {STRING_TOKEN(STR_ES_MP), &gEfiExtendedSalMpServicesProtocolGuid, NULL},\r
2081 {STRING_TOKEN(STR_ES_PAL), &gEfiExtendedSalPalServicesProtocolGuid, NULL},\r
2082 {STRING_TOKEN(STR_ES_BASE), &gEfiExtendedSalBaseServicesProtocolGuid, NULL},\r
2083 {STRING_TOKEN(STR_ES_MCA), &gEfiExtendedSalMcaServicesProtocolGuid, NULL},\r
2084 {STRING_TOKEN(STR_ES_PCI), &gEfiExtendedSalPciServicesProtocolGuid, NULL},\r
2085 {STRING_TOKEN(STR_ES_CACHE), &gEfiExtendedSalCacheServicesProtocolGuid, NULL},\r
2086 {STRING_TOKEN(STR_ES_MCA_LOG), &gEfiExtendedSalMcaLogServicesProtocolGuid, NULL},\r
2087 {STRING_TOKEN(STR_S2ARCH), &gEfiSecurity2ArchProtocolGuid, NULL},\r
2088 {STRING_TOKEN(STR_EODXE), &gEfiSmmEndOfDxeProtocolGuid, NULL},\r
2089 {STRING_TOKEN(STR_ISAHC), &gEfiIsaHcProtocolGuid, NULL},\r
2090 {STRING_TOKEN(STR_ISAHC_B), &gEfiIsaHcServiceBindingProtocolGuid, NULL},\r
2091 {STRING_TOKEN(STR_SIO_C), &gEfiSioControlProtocolGuid, NULL},\r
2092 {STRING_TOKEN(STR_GET_PCD), &gEfiGetPcdInfoProtocolGuid, NULL},\r
2093 {STRING_TOKEN(STR_I2C_M), &gEfiI2cMasterProtocolGuid, NULL},\r
2094 {STRING_TOKEN(STR_I2CIO), &gEfiI2cIoProtocolGuid, NULL},\r
2095 {STRING_TOKEN(STR_I2CEN), &gEfiI2cEnumerateProtocolGuid, NULL},\r
2096 {STRING_TOKEN(STR_I2C_H), &gEfiI2cHostProtocolGuid, NULL},\r
2097 {STRING_TOKEN(STR_I2C_BCM), &gEfiI2cBusConfigurationManagementProtocolGuid, NULL},\r
2098 {STRING_TOKEN(STR_TREE), &gEfiTrEEProtocolGuid, NULL},\r
2099 {STRING_TOKEN(STR_TCG2), &gEfiTcg2ProtocolGuid, NULL},\r
2100 {STRING_TOKEN(STR_TIMESTAMP), &gEfiTimestampProtocolGuid, NULL},\r
2101 {STRING_TOKEN(STR_RNG), &gEfiRngProtocolGuid, NULL},\r
2102 {STRING_TOKEN(STR_NVMEPT), &gEfiNvmExpressPassThruProtocolGuid, NULL},\r
2103 {STRING_TOKEN(STR_H2_SB), &gEfiHash2ServiceBindingProtocolGuid, NULL},\r
2104 {STRING_TOKEN(STR_HASH2), &gEfiHash2ProtocolGuid, NULL},\r
2105 {STRING_TOKEN(STR_BIO_C), &gEfiBlockIoCryptoProtocolGuid, NULL},\r
2106 {STRING_TOKEN(STR_SCR), &gEfiSmartCardReaderProtocolGuid, NULL},\r
2107 {STRING_TOKEN(STR_SCE), &gEfiSmartCardEdgeProtocolGuid, NULL},\r
2108 {STRING_TOKEN(STR_USB_FIO), &gEfiUsbFunctionIoProtocolGuid, NULL},\r
2109 {STRING_TOKEN(STR_BC_HC), &gEfiBluetoothHcProtocolGuid, NULL},\r
2110 {STRING_TOKEN(STR_BC_IO_SB), &gEfiBluetoothIoServiceBindingProtocolGuid, NULL},\r
2111 {STRING_TOKEN(STR_BC_IO), &gEfiBluetoothIoProtocolGuid, NULL},\r
2112 {STRING_TOKEN(STR_BC_C), &gEfiBluetoothConfigProtocolGuid, NULL},\r
2113 {STRING_TOKEN(STR_REG_EXP), &gEfiRegularExpressionProtocolGuid, NULL},\r
2114 {STRING_TOKEN(STR_B_MGR_P), &gEfiBootManagerPolicyProtocolGuid, NULL},\r
2115 {STRING_TOKEN(STR_CKH), &gEfiConfigKeywordHandlerProtocolGuid, NULL},\r
2116 {STRING_TOKEN(STR_WIFI), &gEfiWiFiProtocolGuid, NULL},\r
2117 {STRING_TOKEN(STR_EAP_M), &gEfiEapManagement2ProtocolGuid, NULL},\r
2118 {STRING_TOKEN(STR_EAP_C), &gEfiEapConfigurationProtocolGuid, NULL},\r
2119 {STRING_TOKEN(STR_PKCS7), &gEfiPkcs7VerifyProtocolGuid, NULL},\r
2120 {STRING_TOKEN(STR_NET_DNS4_SB), &gEfiDns4ServiceBindingProtocolGuid, NULL},\r
2121 {STRING_TOKEN(STR_NET_DNS4), &gEfiDns4ProtocolGuid, NULL},\r
2122 {STRING_TOKEN(STR_NET_DNS6_SB), &gEfiDns6ServiceBindingProtocolGuid, NULL},\r
2123 {STRING_TOKEN(STR_NET_DNS6), &gEfiDns6ProtocolGuid, NULL},\r
2124 {STRING_TOKEN(STR_NET_HTTP_SB), &gEfiHttpServiceBindingProtocolGuid, NULL},\r
2125 {STRING_TOKEN(STR_NET_HTTP), &gEfiHttpProtocolGuid, NULL},\r
2126 {STRING_TOKEN(STR_NET_HTTP_U), &gEfiHttpUtilitiesProtocolGuid, NULL},\r
2127 {STRING_TOKEN(STR_REST), &gEfiRestProtocolGuid, NULL},\r
2128\r
0a1eb97d
JC		 2129//\r
2130// UEFI Shell Spec 2.0\r
2131//\r
2132 {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
2133 {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
2134\r
2135//\r
2136// UEFI Shell Spec 2.1\r
2137//\r
2138 {STRING_TOKEN(STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL},\r
2139\r
c2788f1c
JC		 2140//\r
2141// Misc\r
2142//\r
2143 {STRING_TOKEN(STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL},\r
2144\r
dee34318 2145//\r
2146// terminator\r
2147//\r
0e88348e 2148 {0, NULL, NULL},\r
a405b86d 2149};\r
2150\r
2151/**\r
2152 Function to get the node for a protocol or struct from it's GUID.\r
2153\r
2154 if Guid is NULL, then ASSERT.\r
2155\r
2156 @param[in] Guid The GUID to look for the name of.\r
2157\r
2158 @return The node.\r
2159**/\r
dee34318 2160CONST GUID_INFO_BLOCK *\r
a405b86d 2161InternalShellGetNodeFromGuid(\r
2162 IN CONST EFI_GUID* Guid\r
2163 )\r
2164{\r
dee34318 2165 CONST GUID_INFO_BLOCK *ListWalker;\r
6306fd90 2166 UINTN LoopCount;\r
a405b86d 2167\r
2168 ASSERT(Guid != NULL);\r
2169\r
d4ec9a57 2170 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 2171 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2172 return (ListWalker);\r
2173 }\r
2174 }\r
2175\r
a405b86d 2176 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
2177 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2178 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2179 return (ListWalker);\r
2180 }\r
2181 }\r
2182 }\r
2183 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2184 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2185 return (ListWalker);\r
2186 }\r
2187 }\r
6306fd90
JC		 2188 return (NULL);\r
2189}\r
2190\r
2191/**\r
2192Function to add a new GUID/Name mapping.\r
2193\r
2194@param[in] Guid The Guid\r
f5ba4007
QS		 2195@param[in] NameID The STRING id of the HII string to use\r
2196@param[in] DumpFunc The pointer to the dump function\r
6306fd90
JC		 2197\r
2198\r
2199@retval EFI_SUCCESS The operation was sucessful\r
2200@retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
2201@retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
2202**/\r
6306fd90 2203EFI_STATUS\r
6306fd90
JC		 2204InsertNewGuidNameMapping(\r
2205 IN CONST EFI_GUID *Guid,\r
2206 IN CONST EFI_STRING_ID NameID,\r
2207 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL\r
2208 )\r
2209{\r
2210 ASSERT(Guid != NULL);\r
2211 ASSERT(NameID != 0);\r
2212\r
d4ec9a57
RN		 2213 mGuidList = ReallocatePool(mGuidListCount * sizeof(GUID_INFO_BLOCK), mGuidListCount+1 * sizeof(GUID_INFO_BLOCK), mGuidList);\r
2214 if (mGuidList == NULL) {\r
2215 mGuidListCount = 0;\r
6306fd90
JC		 2216 return (EFI_OUT_OF_RESOURCES);\r
2217 }\r
d4ec9a57 2218 mGuidListCount++;\r
6306fd90 2219\r
d4ec9a57
RN		 2220 mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool(sizeof(EFI_GUID), Guid);\r
2221 mGuidList[mGuidListCount - 1].StringId = NameID;\r
2222 mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r
6306fd90 2223\r
d4ec9a57 2224 if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r
6306fd90
JC		 2225 return (EFI_OUT_OF_RESOURCES);\r
2226 }\r
2227\r
2228 return (EFI_SUCCESS);\r
2229}\r
2230\r
2231/**\r
2232 Function to add a new GUID/Name mapping.\r
2233\r
2234 This cannot overwrite an existing mapping.\r
2235\r
2236 @param[in] Guid The Guid\r
2237 @param[in] TheName The Guid's name\r
2238 @param[in] Lang RFC4646 language code list or NULL\r
2239\r
2240 @retval EFI_SUCCESS The operation was sucessful\r
2241 @retval EFI_ACCESS_DENIED There was a duplicate\r
2242 @retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
2243 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL\r
2244**/\r
2245EFI_STATUS\r
2246EFIAPI\r
2247AddNewGuidNameMapping(\r
2248 IN CONST EFI_GUID *Guid,\r
2249 IN CONST CHAR16 *TheName,\r
2250 IN CONST CHAR8 *Lang OPTIONAL\r
2251 )\r
2252{\r
6306fd90
JC		 2253 EFI_STRING_ID NameID;\r
2254\r
e7e0e42b
CP		 2255 HandleParsingHiiInit();\r
2256\r
6306fd90
JC		 2257 if (Guid == NULL || TheName == NULL){\r
2258 return (EFI_INVALID_PARAMETER);\r
2259 }\r
2260\r
931b2cff 2261 if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {\r
6306fd90
JC		 2262 return (EFI_ACCESS_DENIED);\r
2263 }\r
2264\r
2265 NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);\r
2266 if (NameID == 0) {\r
2267 return (EFI_OUT_OF_RESOURCES);\r
2268 }\r
2269\r
2270 return (InsertNewGuidNameMapping(Guid, NameID, NULL));\r
a405b86d 2271}\r
2272\r
2273/**\r
2274 Function to get the name of a protocol or struct from it's GUID.\r
2275\r
2276 if Guid is NULL, then ASSERT.\r
2277\r
2278 @param[in] Guid The GUID to look for the name of.\r
2279 @param[in] Lang The language to use.\r
2280\r
2281 @return pointer to string of the name. The caller\r
2282 is responsible to free this memory.\r
2283**/\r
2284CHAR16*\r
2285EFIAPI\r
2286GetStringNameFromGuid(\r
2287 IN CONST EFI_GUID *Guid,\r
2288 IN CONST CHAR8 *Lang OPTIONAL\r
2289 )\r
2290{\r
dee34318 2291 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2292\r
e7e0e42b
CP		 2293 HandleParsingHiiInit();\r
2294\r
a405b86d 2295 Id = InternalShellGetNodeFromGuid(Guid);\r
0e88348e
RN		 2296 if (Id == NULL) {\r
2297 return NULL;\r
2298 }\r
2299 return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r
a405b86d 2300}\r
2301\r
2302/**\r
2303 Function to dump protocol information from a handle.\r
2304\r
2305 This function will return a allocated string buffer containing the\r
2306 information. The caller is responsible for freeing the memory.\r
2307\r
2308 If Guid is NULL, ASSERT().\r
2309 If TheHandle is NULL, ASSERT().\r
2310\r
2311 @param[in] TheHandle The handle to dump information from.\r
2312 @param[in] Guid The GUID of the protocol to dump.\r
2313 @param[in] Verbose TRUE for extra info. FALSE otherwise.\r
2314\r
2315 @return The pointer to string.\r
2316 @retval NULL An error was encountered.\r
2317**/\r
2318CHAR16*\r
2319EFIAPI\r
2320GetProtocolInformationDump(\r
2321 IN CONST EFI_HANDLE TheHandle,\r
2322 IN CONST EFI_GUID *Guid,\r
2323 IN CONST BOOLEAN Verbose\r
2324 )\r
2325{\r
dee34318 2326 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2327\r
2328 ASSERT(TheHandle != NULL);\r
2329 ASSERT(Guid != NULL);\r
2330\r
2331 if (TheHandle == NULL || Guid == NULL) {\r
2332 return (NULL);\r
2333 }\r
2334\r
2335 Id = InternalShellGetNodeFromGuid(Guid);\r
2336 if (Id != NULL && Id->DumpInfo != NULL) {\r
2337 return (Id->DumpInfo(TheHandle, Verbose));\r
2338 }\r
2339 return (NULL);\r
2340}\r
2341\r
2342/**\r
2343 Function to get the Guid for a protocol or struct based on it's string name.\r
2344\r
0a1eb97d
JC		 2345 do not modify the returned Guid.\r
2346\r
a405b86d 2347 @param[in] Name The pointer to the string name.\r
2348 @param[in] Lang The pointer to the language code.\r
0a1eb97d 2349 @param[out] Guid The pointer to the Guid.\r
a405b86d 2350\r
2351 @retval EFI_SUCCESS The operation was sucessful.\r
2352**/\r
2353EFI_STATUS\r
2354EFIAPI\r
2355GetGuidFromStringName(\r
2356 IN CONST CHAR16 *Name,\r
2357 IN CONST CHAR8 *Lang OPTIONAL,\r
0a1eb97d 2358 OUT EFI_GUID **Guid\r
a405b86d 2359 )\r
2360{\r
dee34318 2361 CONST GUID_INFO_BLOCK *ListWalker;\r
a405b86d 2362 CHAR16 *String;\r
6306fd90 2363 UINTN LoopCount;\r
a405b86d 2364\r
e7e0e42b
CP		 2365 HandleParsingHiiInit();\r
2366\r
a405b86d 2367 ASSERT(Guid != NULL);\r
2368 if (Guid == NULL) {\r
2369 return (EFI_INVALID_PARAMETER);\r
2370 }\r
2371 *Guid = NULL;\r
2372\r
2373 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
2374 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2375 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2376 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2377 *Guid = ListWalker->GuidId;\r
2378 }\r
2379 SHELL_FREE_NON_NULL(String);\r
2380 if (*Guid != NULL) {\r
2381 return (EFI_SUCCESS);\r
2382 }\r
2383 }\r
2384 }\r
2385 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2386 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2387 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2388 *Guid = ListWalker->GuidId;\r
2389 }\r
2390 SHELL_FREE_NON_NULL(String);\r
2391 if (*Guid != NULL) {\r
2392 return (EFI_SUCCESS);\r
2393 }\r
2394 }\r
6306fd90 2395\r
d4ec9a57 2396 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 2397 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
2398 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
2399 *Guid = ListWalker->GuidId;\r
2400 }\r
2401 SHELL_FREE_NON_NULL(String);\r
2402 if (*Guid != NULL) {\r
2403 return (EFI_SUCCESS);\r
2404 }\r
2405 }\r
2406\r
a405b86d 2407 return (EFI_NOT_FOUND);\r
2408}\r
2409\r
36384ceb
ED		 2410/**\r
2411 Get best support language for this driver.\r
1a6f74d9
CS		 2412\r
2413 First base on the user input language to search, second base on the current\r
2414 platform used language to search, third get the first language from the\r
a71003f2 2415 support language list. The caller need to free the buffer of the best language.\r
36384ceb
ED		 2416\r
2417 @param[in] SupportedLanguages The support languages for this driver.\r
a71003f2 2418 @param[in] InputLanguage The user input language.\r
36384ceb
ED		 2419 @param[in] Iso639Language Whether get language for ISO639.\r
2420\r
2421 @return The best support language for this driver.\r
2422**/\r
2423CHAR8 *\r
a71003f2 2424EFIAPI\r
36384ceb 2425GetBestLanguageForDriver (\r
a71003f2
ED		 2426 IN CONST CHAR8 *SupportedLanguages,\r
2427 IN CONST CHAR8 *InputLanguage,\r
36384ceb
ED		 2428 IN BOOLEAN Iso639Language\r
2429 )\r
2430{\r
2431 CHAR8 *LanguageVariable;\r
2432 CHAR8 *BestLanguage;\r
2433\r
3cdd434e 2434 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);\r
36384ceb
ED		 2435\r
2436 BestLanguage = GetBestLanguage(\r
2437 SupportedLanguages,\r
2438 Iso639Language,\r
a71003f2 2439 (InputLanguage != NULL) ? InputLanguage : "",\r
36384ceb 2440 (LanguageVariable != NULL) ? LanguageVariable : "",\r
a71003f2 2441 SupportedLanguages,\r
36384ceb
ED		 2442 NULL\r
2443 );\r
2444\r
2445 if (LanguageVariable != NULL) {\r
2446 FreePool (LanguageVariable);\r
2447 }\r
2448\r
2449 return BestLanguage;\r
2450}\r
2451\r
a405b86d 2452/**\r
2453 Function to retrieve the driver name (if possible) from the ComponentName or\r
2454 ComponentName2 protocol\r
2455\r
2456 @param[in] TheHandle The driver handle to get the name of.\r
2457 @param[in] Language The language to use.\r
2458\r
2459 @retval NULL The name could not be found.\r
2460 @return A pointer to the string name. Do not de-allocate the memory.\r
2461**/\r
2462CONST CHAR16*\r
2463EFIAPI\r
2464GetStringNameFromHandle(\r
2465 IN CONST EFI_HANDLE TheHandle,\r
2466 IN CONST CHAR8 *Language\r
2467 )\r
2468{\r
2469 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;\r
2470 EFI_STATUS Status;\r
2471 CHAR16 *RetVal;\r
36384ceb
ED		 2472 CHAR8 *BestLang;\r
2473\r
2474 BestLang = NULL;\r
a405b86d 2475\r
2476 Status = gBS->OpenProtocol(\r
2477 TheHandle,\r
2478 &gEfiComponentName2ProtocolGuid,\r
2479 (VOID**)&CompNameStruct,\r
2480 gImageHandle,\r
2481 NULL,\r
2482 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2483 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2484 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2485 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2486 if (BestLang != NULL) {\r
2487 FreePool (BestLang);\r
2488 BestLang = NULL;\r
2489 }\r
a405b86d 2490 if (!EFI_ERROR(Status)) {\r
2491 return (RetVal);\r
2492 }\r
2493 }\r
2494 Status = gBS->OpenProtocol(\r
2495 TheHandle,\r
2496 &gEfiComponentNameProtocolGuid,\r
2497 (VOID**)&CompNameStruct,\r
2498 gImageHandle,\r
2499 NULL,\r
2500 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2501 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2502 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2503 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2504 if (BestLang != NULL) {\r
2505 FreePool (BestLang);\r
2506 }\r
a405b86d 2507 if (!EFI_ERROR(Status)) {\r
2508 return (RetVal);\r
2509 }\r
2510 }\r
2511 return (NULL);\r
2512}\r
2513\r
2514/**\r
2515 Function to initialize the file global mHandleList object for use in\r
2516 vonverting handles to index and index to handle.\r
2517\r
2518 @retval EFI_SUCCESS The operation was successful.\r
2519**/\r
2520EFI_STATUS\r
a405b86d 2521InternalShellInitHandleList(\r
2522 VOID\r
2523 )\r
2524{\r
2525 EFI_STATUS Status;\r
2526 EFI_HANDLE *HandleBuffer;\r
2527 UINTN HandleCount;\r
2528 HANDLE_LIST *ListWalker;\r
2529\r
2530 if (mHandleList.NextIndex != 0) {\r
2531 return EFI_SUCCESS;\r
2532 }\r
2533 InitializeListHead(&mHandleList.List.Link);\r
2534 mHandleList.NextIndex = 1;\r
2535 Status = gBS->LocateHandleBuffer (\r
2536 AllHandles,\r
2537 NULL,\r
2538 NULL,\r
2539 &HandleCount,\r
2540 &HandleBuffer\r
2541 );\r
2542 ASSERT_EFI_ERROR(Status);\r
2543 if (EFI_ERROR(Status)) {\r
2544 return (Status);\r
2545 }\r
2546 for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
78ed876b 2547 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2548 if (ListWalker != NULL) {\r
2549 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
2550 ListWalker->TheIndex = mHandleList.NextIndex;\r
2551 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
2552 }\r
a405b86d 2553 }\r
2554 FreePool(HandleBuffer);\r
2555 return (EFI_SUCCESS);\r
2556}\r
2557\r
2558/**\r
2559 Function to retrieve the human-friendly index of a given handle. If the handle\r
2560 does not have a index one will be automatically assigned. The index value is valid\r
2561 until the termination of the shell application.\r
2562\r
2563 @param[in] TheHandle The handle to retrieve an index for.\r
2564\r
2565 @retval 0 A memory allocation failed.\r
2566 @return The index of the handle.\r
2567\r
2568**/\r
2569UINTN\r
2570EFIAPI\r
2571ConvertHandleToHandleIndex(\r
2572 IN CONST EFI_HANDLE TheHandle\r
2573 )\r
2574{\r
f330ff35 2575 EFI_STATUS Status;\r
2576 EFI_GUID **ProtocolBuffer;\r
2577 UINTN ProtocolCount;\r
2578 HANDLE_LIST *ListWalker;\r
2579\r
78ed876b 2580 if (TheHandle == NULL) {\r
2581 return 0;\r
2582 }\r
a405b86d 2583\r
2584 InternalShellInitHandleList();\r
2585\r
2586 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2587 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2588 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2589 ){\r
2590 if (ListWalker->TheHandle == TheHandle) {\r
f330ff35 2591 //\r
2592 // Verify that TheHandle is still present in the Handle Database\r
2593 //\r
2594 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2595 if (EFI_ERROR (Status)) {\r
2596 //\r
2597 // TheHandle is not present in the Handle Database, so delete from the handle list\r
2598 //\r
2599 RemoveEntryList (&ListWalker->Link);\r
2600 return 0;\r
2601 }\r
2602 FreePool (ProtocolBuffer);\r
a405b86d 2603 return (ListWalker->TheIndex);\r
2604 }\r
2605 }\r
f330ff35 2606\r
2607 //\r
2608 // Verify that TheHandle is valid handle\r
2609 //\r
2610 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2611 if (EFI_ERROR (Status)) {\r
2612 //\r
2613 // TheHandle is not valid, so do not add to handle list\r
2614 //\r
2615 return 0;\r
2616 }\r
2617 FreePool (ProtocolBuffer);\r
2618\r
78ed876b 2619 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2620 if (ListWalker == NULL) {\r
2621 return 0;\r
2622 }\r
a405b86d 2623 ListWalker->TheHandle = TheHandle;\r
2624 ListWalker->TheIndex = mHandleList.NextIndex++;\r
2625 InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
2626 return (ListWalker->TheIndex);\r
2627}\r
2628\r
2629\r
2630\r
2631/**\r
2632 Function to retrieve the EFI_HANDLE from the human-friendly index.\r
2633\r
2634 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.\r
2635\r
2636 @retval NULL The index was invalid.\r
2637 @return The EFI_HANDLE that index represents.\r
2638\r
2639**/\r
2640EFI_HANDLE\r
2641EFIAPI\r
2642ConvertHandleIndexToHandle(\r
2643 IN CONST UINTN TheIndex\r
2644 )\r
2645{\r
f330ff35 2646 EFI_STATUS Status;\r
2647 EFI_GUID **ProtocolBuffer;\r
2648 UINTN ProtocolCount;\r
a405b86d 2649 HANDLE_LIST *ListWalker;\r
2650\r
2651 InternalShellInitHandleList();\r
2652\r
2653 if (TheIndex >= mHandleList.NextIndex) {\r
f330ff35 2654 return NULL;\r
a405b86d 2655 }\r
2656\r
2657 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2658 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2659 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2660 ){\r
f330ff35 2661 if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {\r
2662 //\r
2663 // Verify that LinkWalker->TheHandle is valid handle\r
2664 //\r
2665 Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
00324f3f
RN		 2666 if (!EFI_ERROR (Status)) {\r
2667 FreePool (ProtocolBuffer);\r
2668 } else {\r
f330ff35 2669 //\r
2670 // TheHandle is not valid, so do not add to handle list\r
2671 //\r
2672 ListWalker->TheHandle = NULL;\r
2673 }\r
a405b86d 2674 return (ListWalker->TheHandle);\r
2675 }\r
2676 }\r
f330ff35 2677 return NULL;\r
a405b86d 2678}\r
2679\r
2680/**\r
2681 Gets all the related EFI_HANDLEs based on the mask supplied.\r
2682\r
2683 This function scans all EFI_HANDLES in the UEFI environment's handle database\r
2684 and returns the ones with the specified relationship (Mask) to the specified\r
2685 controller handle.\r
2686\r
2687 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
2688 If MatchingHandleCount is NULL, then ASSERT.\r
2689\r
2690 If MatchingHandleBuffer is not NULL upon a successful return the memory must be\r
2691 caller freed.\r
2692\r
2693 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.\r
2694 @param[in] ControllerHandle The handle with Device Path protocol on it.\r
2695 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in\r
2696 MatchingHandleBuffer.\r
2697 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount\r
2698 EFI_HANDLEs with a terminating NULL EFI_HANDLE.\r
2699 @param[out] HandleType An array of type information.\r
2700\r
2701 @retval EFI_SUCCESS The operation was successful, and any related handles\r
2702 are in MatchingHandleBuffer.\r
2703 @retval EFI_NOT_FOUND No matching handles were found.\r
2704 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
2705**/\r
2706EFI_STATUS\r
2707EFIAPI\r
2708ParseHandleDatabaseByRelationshipWithType (\r
2709 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
2710 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
2711 IN UINTN *HandleCount,\r
2712 OUT EFI_HANDLE **HandleBuffer,\r
2713 OUT UINTN **HandleType\r
2714 )\r
2715{\r
2716 EFI_STATUS Status;\r
2717 UINTN HandleIndex;\r
2718 EFI_GUID **ProtocolGuidArray;\r
2719 UINTN ArrayCount;\r
2720 UINTN ProtocolIndex;\r
2721 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;\r
2722 UINTN OpenInfoCount;\r
2723 UINTN OpenInfoIndex;\r
2724 UINTN ChildIndex;\r
f330ff35 2725 INTN DriverBindingHandleIndex;\r
a405b86d 2726\r
2727 ASSERT(HandleCount != NULL);\r
2728 ASSERT(HandleBuffer != NULL);\r
2729 ASSERT(HandleType != NULL);\r
2730 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
2731\r
2732 *HandleCount = 0;\r
2733 *HandleBuffer = NULL;\r
2734 *HandleType = NULL;\r
2735\r
2736 //\r
2737 // Retrieve the list of all handles from the handle database\r
2738 //\r
2739 Status = gBS->LocateHandleBuffer (\r
2740 AllHandles,\r
2741 NULL,\r
2742 NULL,\r
2743 HandleCount,\r
2744 HandleBuffer\r
2745 );\r
2746 if (EFI_ERROR (Status)) {\r
2747 return (Status);\r
2748 }\r
2749\r
2750 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
aa3276c1
RN		 2751 if (*HandleType == NULL) {\r
2752 SHELL_FREE_NON_NULL (*HandleBuffer);\r
94fcb76b 2753 *HandleCount = 0;\r
aa3276c1
RN		 2754 return EFI_OUT_OF_RESOURCES;\r
2755 }\r
a405b86d 2756\r
f330ff35 2757 DriverBindingHandleIndex = -1;\r
2758 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
2759 if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {\r
2760 DriverBindingHandleIndex = (INTN)HandleIndex;\r
2761 }\r
2762 }\r
2763\r
a405b86d 2764 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
2765 //\r
2766 // Retrieve the list of all the protocols on each handle\r
2767 //\r
2768 Status = gBS->ProtocolsPerHandle (\r
2769 (*HandleBuffer)[HandleIndex],\r
2770 &ProtocolGuidArray,\r
2771 &ArrayCount\r
2772 );\r
f330ff35 2773 if (EFI_ERROR (Status)) {\r
2774 continue;\r
2775 }\r
a405b86d 2776\r
f330ff35 2777 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
a405b86d 2778\r
f330ff35 2779 //\r
2780 // Set the bit describing what this handle has\r
2781 //\r
2782 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
7aae3c35 2783 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
f330ff35 2784 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
7aae3c35 2785 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
f330ff35 2786 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
7aae3c35 2787 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 2788 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
7aae3c35 2789 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 2790 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
7aae3c35 2791 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 2792 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
7aae3c35 2793 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 2794 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
7aae3c35 2795 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 2796 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
7aae3c35 2797 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 2798 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
7aae3c35 2799 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
f330ff35 2800 }\r
2801 //\r
2802 // Retrieve the list of agents that have opened each protocol\r
2803 //\r
2804 Status = gBS->OpenProtocolInformation (\r
a405b86d 2805 (*HandleBuffer)[HandleIndex],\r
2806 ProtocolGuidArray[ProtocolIndex],\r
2807 &OpenInfo,\r
2808 &OpenInfoCount\r
2809 );\r
f330ff35 2810 if (EFI_ERROR (Status)) {\r
2811 continue;\r
2812 }\r
2813\r
2814 if (ControllerHandle == NULL) {\r
2815 //\r
1a6f74d9 2816 // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
f330ff35 2817 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing\r
2818 //\r
2819 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2820 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
7aae3c35 2821 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2822 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2823 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 2824 }\r
2825 }\r
2826 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
7aae3c35 2827 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2828 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2829 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2830 }\r
2831 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2832 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2833 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
f330ff35 2834 }\r
2835 }\r
2836 }\r
2837 }\r
2838 }\r
2839 if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
2840 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 2841 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
a405b86d 2842 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
f330ff35 2843 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
2844 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2845 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2846 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 2847 }\r
a405b86d 2848 }\r
f330ff35 2849 }\r
2850 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2851 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2852 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2853 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2854 }\r
2855 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2856 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 2857 }\r
2858 }\r
2859 }\r
f330ff35 2860 }\r
2861 } else {\r
2862 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2863 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2864 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 2865 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 2866 }\r
2867 }\r
2868 }\r
2869 }\r
2870 }\r
2871 if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
2872 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 2873 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2874 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2875 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
2876 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
2877 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2878 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
a405b86d 2879 }\r
2880 }\r
f330ff35 2881 }\r
2882 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2883 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
a405b86d 2884 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
f330ff35 2885 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2886 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 2887 }\r
2888 }\r
2889 }\r
f330ff35 2890\r
2891 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2892 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2893 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2894 }\r
2895 }\r
2896 }\r
2897 }\r
2898 } else {\r
2899 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2900 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2901 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 2902 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 2903 }\r
a405b86d 2904 }\r
2905 }\r
a405b86d 2906 }\r
2907 }\r
f330ff35 2908 FreePool (OpenInfo);\r
a405b86d 2909 }\r
f330ff35 2910 FreePool (ProtocolGuidArray);\r
a405b86d 2911 }\r
f330ff35 2912 return EFI_SUCCESS;\r
a405b86d 2913}\r
2914\r
2915/**\r
2916 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask\r
2917 supplied.\r
2918\r
2919 This function will scan all EFI_HANDLES in the UEFI environment's handle database\r
2920 and return all the ones with the specified relationship (Mask) to the specified\r
2921 controller handle.\r
2922\r
2923 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
2924 If MatchingHandleCount is NULL, then ASSERT.\r
2925\r
2926 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be\r
2927 caller freed.\r
2928\r
2929 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol\r
2930 on it.\r
2931 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.\r
2932 @param[in] Mask Mask of what relationship(s) is desired.\r
2933 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in\r
2934 MatchingHandleBuffer.\r
2935 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount\r
2936 EFI_HANDLEs and a terminating NULL EFI_HANDLE.\r
2937\r
2938 @retval EFI_SUCCESS The operation was sucessful and any related handles\r
2939 are in MatchingHandleBuffer;\r
2940 @retval EFI_NOT_FOUND No matching handles were found.\r
2941 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
2942**/\r
2943EFI_STATUS\r
2944EFIAPI\r
2945ParseHandleDatabaseByRelationship (\r
2946 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
2947 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
2948 IN CONST UINTN Mask,\r
2949 IN UINTN *MatchingHandleCount,\r
2950 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
2951 )\r
2952{\r
2953 EFI_STATUS Status;\r
2954 UINTN HandleCount;\r
2955 EFI_HANDLE *HandleBuffer;\r
2956 UINTN *HandleType;\r
2957 UINTN HandleIndex;\r
2958\r
2959 ASSERT(MatchingHandleCount != NULL);\r
2960 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
2961\r
2962 if ((Mask & HR_VALID_MASK) != Mask) {\r
2963 return (EFI_INVALID_PARAMETER);\r
2964 }\r
2965\r
2966 if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {\r
2967 return (EFI_INVALID_PARAMETER);\r
2968 }\r
2969\r
2970 *MatchingHandleCount = 0;\r
2971 if (MatchingHandleBuffer != NULL) {\r
2972 *MatchingHandleBuffer = NULL;\r
2973 }\r
2974\r
2975 HandleBuffer = NULL;\r
2976 HandleType = NULL;\r
2977\r
2978 Status = ParseHandleDatabaseByRelationshipWithType (\r
2979 DriverBindingHandle,\r
2980 ControllerHandle,\r
2981 &HandleCount,\r
2982 &HandleBuffer,\r
2983 &HandleType\r
2984 );\r
2985 if (!EFI_ERROR (Status)) {\r
2986 //\r
2987 // Count the number of handles that match the attributes in Mask\r
2988 //\r
2989 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {\r
2990 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
2991 (*MatchingHandleCount)++;\r
2992 }\r
2993 }\r
2994 //\r
2995 // If no handles match the attributes in Mask then return EFI_NOT_FOUND\r
2996 //\r
2997 if (*MatchingHandleCount == 0) {\r
2998 Status = EFI_NOT_FOUND;\r
2999 } else {\r
3000\r
3001 if (MatchingHandleBuffer == NULL) {\r
3002 //\r
3003 // Someone just wanted the count...\r
3004 //\r
3005 Status = EFI_SUCCESS;\r
3006 } else {\r
3007 //\r
3008 // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
3009 //\r
78ed876b 3010 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
94fcb76b
RN		 3011 if (*MatchingHandleBuffer == NULL) {\r
3012 Status = EFI_OUT_OF_RESOURCES;\r
3013 } else {\r
aa3276c1
RN		 3014 for (HandleIndex = 0, *MatchingHandleCount = 0\r
3015 ; HandleIndex < HandleCount\r
3016 ; HandleIndex++\r
3017 ) {\r
3018 //\r
3019 // Fill the allocated buffer with the handles that matched the attributes in Mask\r
3020 //\r
3021 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
3022 (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
3023 }\r
3024 }\r
a405b86d 3025\r
a405b86d 3026 //\r
aa3276c1 3027 // Make the last one NULL\r
a405b86d 3028 //\r
aa3276c1 3029 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
a405b86d 3030\r
aa3276c1 3031 Status = EFI_SUCCESS;\r
94fcb76b 3032 } // *MatchingHandleBuffer == NULL (ELSE)\r
a405b86d 3033 } // MacthingHandleBuffer == NULL (ELSE)\r
3034 } // *MatchingHandleCount == 0 (ELSE)\r
3035 } // no error on ParseHandleDatabaseByRelationshipWithType\r
3036\r
3037 if (HandleBuffer != NULL) {\r
3038 FreePool (HandleBuffer);\r
3039 }\r
3040\r
3041 if (HandleType != NULL) {\r
3042 FreePool (HandleType);\r
3043 }\r
3044\r
94fcb76b
RN		 3045 ASSERT ((MatchingHandleBuffer == NULL) ||\r
3046 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3047 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 3048 return Status;\r
3049}\r
3050\r
3051/**\r
3052 Gets handles for any child controllers of the passed in controller.\r
3053\r
3054 @param[in] ControllerHandle The handle of the "parent controller"\r
b6c54204 3055 @param[out] MatchingHandleCount Pointer to the number of handles in\r
a405b86d 3056 MatchingHandleBuffer on return.\r
3057 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
3058 return.\r
3059\r
3060\r
3061 @retval EFI_SUCCESS The operation was sucessful.\r
3062**/\r
3063EFI_STATUS\r
3064EFIAPI\r
3065ParseHandleDatabaseForChildControllers(\r
3066 IN CONST EFI_HANDLE ControllerHandle,\r
b6c54204 3067 OUT UINTN *MatchingHandleCount,\r
a405b86d 3068 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3069 )\r
3070{\r
3071 EFI_STATUS Status;\r
f330ff35 3072 UINTN HandleIndex;\r
a405b86d 3073 UINTN DriverBindingHandleCount;\r
3074 EFI_HANDLE *DriverBindingHandleBuffer;\r
3075 UINTN DriverBindingHandleIndex;\r
3076 UINTN ChildControllerHandleCount;\r
3077 EFI_HANDLE *ChildControllerHandleBuffer;\r
3078 UINTN ChildControllerHandleIndex;\r
a405b86d 3079 EFI_HANDLE *HandleBufferForReturn;\r
3080\r
ff51746b 3081 if (MatchingHandleCount == NULL) {\r
3082 return (EFI_INVALID_PARAMETER);\r
3083 }\r
64d753f1 3084 *MatchingHandleCount = 0;\r
a405b86d 3085\r
3086 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
3087 ControllerHandle,\r
3088 &DriverBindingHandleCount,\r
3089 &DriverBindingHandleBuffer\r
3090 );\r
3091 if (EFI_ERROR (Status)) {\r
3092 return Status;\r
3093 }\r
3094\r
ff51746b 3095 //\r
3096 // Get a buffer big enough for all the controllers.\r
3097 //\r
f330ff35 3098 HandleBufferForReturn = GetHandleListByProtocol(NULL);\r
a405b86d 3099 if (HandleBufferForReturn == NULL) {\r
3100 FreePool (DriverBindingHandleBuffer);\r
ff51746b 3101 return (EFI_NOT_FOUND);\r
a405b86d 3102 }\r
3103\r
a405b86d 3104 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {\r
3105 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
3106 DriverBindingHandleBuffer[DriverBindingHandleIndex],\r
3107 ControllerHandle,\r
3108 &ChildControllerHandleCount,\r
3109 &ChildControllerHandleBuffer\r
3110 );\r
3111 if (EFI_ERROR (Status)) {\r
3112 continue;\r
3113 }\r
3114\r
3115 for (ChildControllerHandleIndex = 0;\r
3116 ChildControllerHandleIndex < ChildControllerHandleCount;\r
3117 ChildControllerHandleIndex++\r
3118 ) {\r
f330ff35 3119 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {\r
3120 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {\r
3121 break;\r
3122 }\r
3123 }\r
3124 if (HandleIndex >= *MatchingHandleCount) {\r
3125 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];\r
3126 }\r
a405b86d 3127 }\r
3128\r
3129 FreePool (ChildControllerHandleBuffer);\r
3130 }\r
3131\r
3132 FreePool (DriverBindingHandleBuffer);\r
3133\r
7eb3bb6c
LE		 3134 if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {\r
3135 //\r
3136 // The caller is not interested in the actual handles, or we've found none.\r
3137 //\r
3138 FreePool (HandleBufferForReturn);\r
3139 HandleBufferForReturn = NULL;\r
3140 }\r
3141\r
a405b86d 3142 if (MatchingHandleBuffer != NULL) {\r
3143 *MatchingHandleBuffer = HandleBufferForReturn;\r
a405b86d 3144 }\r
7eb3bb6c 3145\r
94fcb76b
RN		 3146 ASSERT ((MatchingHandleBuffer == NULL) ||\r
3147 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3148 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 3149\r
3150 return (EFI_SUCCESS);\r
3151}\r
3152\r
3153/**\r
3154 Appends 1 buffer to another buffer. This will re-allocate the destination buffer\r
3155 if necessary to fit all of the data.\r
3156\r
3157 If DestinationBuffer is NULL, then ASSERT().\r
3158\r
4ff7e37b
ED		 3159 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.\r
3160 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.\r
3161 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.\r
3162 @param[in] SourceSize The number of bytes of SourceBuffer to append.\r
a405b86d 3163\r
3164 @retval NULL A memory allocation failed.\r
3165 @retval NULL A parameter was invalid.\r
3166 @return A pointer to (*DestinationBuffer).\r
3167**/\r
3168VOID*\r
a405b86d 3169BuffernCatGrow (\r
3170 IN OUT VOID **DestinationBuffer,\r
3171 IN OUT UINTN *DestinationSize,\r
3172 IN VOID *SourceBuffer,\r
3173 IN UINTN SourceSize\r
3174 )\r
3175{\r
3176 UINTN LocalDestinationSize;\r
3177 UINTN LocalDestinationFinalSize;\r
3178\r
3179 ASSERT(DestinationBuffer != NULL);\r
3180\r
3181 if (SourceSize == 0 || SourceBuffer == NULL) {\r
3182 return (*DestinationBuffer);\r
3183 }\r
3184\r
3185 if (DestinationSize == NULL) {\r
3186 LocalDestinationSize = 0;\r
3187 } else {\r
3188 LocalDestinationSize = *DestinationSize;\r
3189 }\r
3190\r
3191 LocalDestinationFinalSize = LocalDestinationSize + SourceSize;\r
3192\r
3193 if (DestinationSize != NULL) {\r
3194 *DestinationSize = LocalDestinationSize;\r
3195 }\r
3196\r
3197 if (LocalDestinationSize == 0) {\r
3198 // allcoate\r
78ed876b 3199 *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);\r
a405b86d 3200 } else {\r
3201 // reallocate\r
3202 *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);\r
3203 }\r
3204\r
3205 ASSERT(*DestinationBuffer != NULL);\r
3206\r
3207 // copy\r
3208 return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));\r
3209}\r
3210\r
3211/**\r
3212 Gets handles for any child devices produced by the passed in driver.\r
3213\r
3214 @param[in] DriverHandle The handle of the driver.\r
3215 @param[in] MatchingHandleCount Pointer to the number of handles in\r
3216 MatchingHandleBuffer on return.\r
3217 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
3218 return.\r
3219 @retval EFI_SUCCESS The operation was sucessful.\r
3220 @sa ParseHandleDatabaseByRelationship\r
3221**/\r
3222EFI_STATUS\r
3223EFIAPI\r
3224ParseHandleDatabaseForChildDevices(\r
3225 IN CONST EFI_HANDLE DriverHandle,\r
3226 IN UINTN *MatchingHandleCount,\r
3227 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3228 )\r
3229{\r
3230 EFI_HANDLE *Buffer;\r
3231 EFI_HANDLE *Buffer2;\r
3232 UINTN Count1;\r
3233 UINTN Count2;\r
3234 UINTN HandleIndex;\r
3235 EFI_STATUS Status;\r
3236 UINTN HandleBufferSize;\r
3237\r
3238 ASSERT(MatchingHandleCount != NULL);\r
3239\r
3240 HandleBufferSize = 0;\r
3241 Buffer = NULL;\r
3242 Buffer2 = NULL;\r
3243 *MatchingHandleCount = 0;\r
3244\r
3245 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
3246 DriverHandle,\r
3247 &Count1,\r
3248 &Buffer\r
3249 );\r
3250 if (!EFI_ERROR (Status)) {\r
3251 for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {\r
3252 //\r
3253 // now find the children\r
3254 //\r
3255 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
3256 DriverHandle,\r
3257 Buffer[HandleIndex],\r
3258 &Count2,\r
3259 &Buffer2\r
3260 );\r
3261 if (EFI_ERROR(Status)) {\r
3262 break;\r
3263 }\r
3264 //\r
3265 // save out required and optional data elements\r
3266 //\r
3267 *MatchingHandleCount += Count2;\r
3268 if (MatchingHandleBuffer != NULL) {\r
3269 *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));\r
3270 }\r
3271\r
3272 //\r
3273 // free the memory\r
3274 //\r
3275 if (Buffer2 != NULL) {\r
3276 FreePool(Buffer2);\r
3277 }\r
3278 }\r
3279 }\r
3280\r
3281 if (Buffer != NULL) {\r
3282 FreePool(Buffer);\r
3283 }\r
3284 return (Status);\r
3285}\r
3286\r
3287/**\r
3288 Function to get all handles that support a given protocol or all handles.\r
3289\r
3290 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL\r
3291 then the function will return all handles.\r
3292\r
3293 @retval NULL A memory allocation failed.\r
3294 @return A NULL terminated list of handles.\r
3295**/\r
3296EFI_HANDLE*\r
3297EFIAPI\r
40d7a9cf 3298GetHandleListByProtocol (\r
a405b86d 3299 IN CONST EFI_GUID *ProtocolGuid OPTIONAL\r
3300 )\r
3301{\r
3302 EFI_HANDLE *HandleList;\r
3303 UINTN Size;\r
3304 EFI_STATUS Status;\r
3305\r
3306 Size = 0;\r
3307 HandleList = NULL;\r
3308\r
3309 //\r
3310 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!\r
3311 //\r
3312 if (ProtocolGuid == NULL) {\r
3313 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3314 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3315 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3316 if (HandleList == NULL) {\r
3317 return (NULL);\r
3318 }\r
a405b86d 3319 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3320 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3321 }\r
3322 } else {\r
3323 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3324 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3325 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3326 if (HandleList == NULL) {\r
3327 return (NULL);\r
3328 }\r
a405b86d 3329 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3330 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3331 }\r
3332 }\r
3333 if (EFI_ERROR(Status)) {\r
3334 if (HandleList != NULL) {\r
3335 FreePool(HandleList);\r
3336 }\r
3337 return (NULL);\r
3338 }\r
3339 return (HandleList);\r
3340}\r
3341\r
3342/**\r
3343 Function to get all handles that support some protocols.\r
3344\r
3345 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.\r
3346\r
3347 @retval NULL A memory allocation failed.\r
ff51746b 3348 @retval NULL ProtocolGuids was NULL.\r
3349 @return A NULL terminated list of EFI_HANDLEs.\r
a405b86d 3350**/\r
3351EFI_HANDLE*\r
3352EFIAPI\r
40d7a9cf 3353GetHandleListByProtocolList (\r
a405b86d 3354 IN CONST EFI_GUID **ProtocolGuids\r
3355 )\r
3356{\r
3357 EFI_HANDLE *HandleList;\r
3358 UINTN Size;\r
3359 UINTN TotalSize;\r
40d7a9cf 3360 UINTN TempSize;\r
a405b86d 3361 EFI_STATUS Status;\r
3362 CONST EFI_GUID **GuidWalker;\r
3363 EFI_HANDLE *HandleWalker1;\r
3364 EFI_HANDLE *HandleWalker2;\r
3365\r
3366 Size = 0;\r
3367 HandleList = NULL;\r
3368 TotalSize = sizeof(EFI_HANDLE);\r
3369\r
3370 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){\r
3371 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);\r
3372 if (Status == EFI_BUFFER_TOO_SMALL) {\r
3373 TotalSize += Size;\r
3374 }\r
3375 }\r
40d7a9cf 3376\r
3377 //\r
e918029f 3378 // No handles were found...\r
40d7a9cf 3379 //\r
3380 if (TotalSize == sizeof(EFI_HANDLE)) {\r
3381 return (NULL);\r
3382 }\r
3383\r
3384 HandleList = AllocateZeroPool(TotalSize);\r
a405b86d 3385 if (HandleList == NULL) {\r
3386 return (NULL);\r
3387 }\r
3388\r
3389 Size = 0;\r
3390 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){\r
40d7a9cf 3391 TempSize = TotalSize - Size;\r
ff51746b 3392 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));\r
40d7a9cf 3393\r
3394 //\r
3395 // Allow for missing protocols... Only update the 'used' size upon success.\r
3396 //\r
3397 if (!EFI_ERROR(Status)) {\r
ff51746b 3398 Size += TempSize;\r
40d7a9cf 3399 }\r
a405b86d 3400 }\r
ff51746b 3401 ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);\r
a405b86d 3402\r
3403 for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {\r
3404 for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {\r
3405 if (*HandleWalker1 == *HandleWalker2) {\r
3406 //\r
3407 // copy memory back 1 handle width.\r
3408 //\r
3409 CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));\r
3410 }\r
3411 }\r
3412 }\r
3413\r
3414 return (HandleList);\r
3415}\r
0976f908
CC		 3416\r
3417/**\r
3418 Return all supported GUIDs.\r
3419\r
3420 @param[out] Guids The buffer to return all supported GUIDs.\r
3421 @param[in, out] Count On input, the count of GUIDs the buffer can hold,\r
3422 On output, the count of GUIDs to return.\r
3423\r
3424 @retval EFI_INVALID_PARAMETER Count is NULL.\r
3425 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.\r
3426 @retval EFI_SUCCESS GUIDs are returned successfully.\r
3427**/\r
3428EFI_STATUS\r
3429EFIAPI\r
3430GetAllMappingGuids (\r
3431 OUT EFI_GUID *Guids,\r
3432 IN OUT UINTN *Count\r
3433 )\r
3434{\r
3435 UINTN GuidCount;\r
7c14bc87 3436 UINTN NtGuidCount;\r
0976f908
CC		 3437 UINTN Index;\r
3438\r
3439 if (Count == NULL) {\r
3440 return EFI_INVALID_PARAMETER;\r
3441 }\r
3442\r
3443 NtGuidCount = 0;\r
3444 if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
3445 NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;\r
3446 }\r
3447 GuidCount = ARRAY_SIZE (mGuidStringList) - 1;\r
3448\r
3449 if (*Count < NtGuidCount + GuidCount + mGuidListCount) {\r
3450 *Count = NtGuidCount + GuidCount + mGuidListCount;\r
3451 return EFI_BUFFER_TOO_SMALL;\r
3452 }\r
3453\r
3454 for (Index = 0; Index < NtGuidCount; Index++) {\r
3455 CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);\r
3456 }\r
3457\r
3458 for (Index = 0; Index < GuidCount; Index++) {\r
3459 CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);\r
3460 }\r
3461\r
3462 for (Index = 0; Index < mGuidListCount; Index++) {\r
3463 CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);\r
3464 }\r
3465\r
3466 return EFI_SUCCESS;\r
3467}\r
EFI Development Kit II mirror for PVE