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