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