]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ShellPkg: Fix pci command for '_e' option
[mirror_edk2.git] / ShellPkg / Library / UefiHandleParsingLib / UefiHandleParsingLib.c
... / ...
CommitLineData
1/** @file\r
2 Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
3\r
4 Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>\r
5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r
6 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>\r
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
18#include "IndustryStandard/Acpi10.h"\r
19\r
20EFI_HANDLE mHandleParsingHiiHandle = NULL;\r
21HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};\r
22GUID_INFO_BLOCK *GuidList;\r
23UINTN GuidListCount;\r
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
61/**\r
62 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.\r
63\r
64 @param[in] Fmt The format type.\r
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
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
103 GuidListCount = 0;\r
104 GuidList = NULL;\r
105\r
106 //\r
107 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.\r
108 //\r
109 return (EFI_SUCCESS);\r
110}\r
111\r
112/**\r
113 Initialization function for HII packages.\r
114\r
115**/\r
116VOID\r
117HandleParsingHiiInit (VOID)\r
118{\r
119 if (mHandleParsingHiiHandle == NULL) {\r
120 mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);\r
121 ASSERT (mHandleParsingHiiHandle != NULL);\r
122 }\r
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
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
147 if (mHandleParsingHiiHandle != NULL) {\r
148 HiiRemovePackages(mHandleParsingHiiHandle);\r
149 }\r
150 return (EFI_SUCCESS);\r
151}\r
152\r
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
163CHAR16*\r
164EFIAPI\r
165LoadedImageProtocolDumpInformation(\r
166 IN CONST EFI_HANDLE TheHandle,\r
167 IN CONST BOOLEAN Verbose\r
168 )\r
169{\r
170 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
171 EFI_STATUS Status;\r
172 CHAR16 *RetVal;\r
173 CHAR16 *Temp;\r
174 CHAR16 *CodeType;\r
175 CHAR16 *DataType;\r
176\r
177 if (!Verbose) {\r
178 return (CatSPrint(NULL, L"LoadedImage"));\r
179 }\r
180\r
181 HandleParsingHiiInit();\r
182\r
183 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);\r
184 if (Temp == NULL) {\r
185 return NULL;\r
186 }\r
187\r
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
197 if (EFI_ERROR (Status)) {\r
198 SHELL_FREE_NON_NULL (Temp);\r
199 return NULL;\r
200 }\r
201\r
202 DataType = ConvertMemoryType(LoadedImage->ImageDataType);\r
203 CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);\r
204\r
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
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
228}\r
229\r
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
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;
256\r
257 if (!Verbose) {\r
258 return (CatSPrint(NULL, L"GraphicsOutput"));\r
259 }\r
260\r
261 HandleParsingHiiInit();\r
262\r
263 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);\r
264 if (Temp == NULL) {\r
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
279 return NULL;\r
280 }\r
281\r
282 Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);\r
283\r
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
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
337 SHELL_FREE_NON_NULL(Temp);\r
338 SHELL_FREE_NON_NULL(Fmt);\r
339\r
340 return RetVal;\r
341}\r
342\r
343/**\r
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/**
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
503 HandleParsingHiiInit();\r
504\r
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
515 if (Temp == NULL) {\r
516 return NULL;\r
517 }\r
518 Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);\r
519 FreePool(Temp);\r
520 RetVal = Temp2;\r
521 Temp2 = NULL;\r
522\r
523 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);\r
524 if (Temp == NULL) {\r
525 SHELL_FREE_NON_NULL(RetVal);\r
526 return NULL;\r
527 }\r
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
539 if (Temp == NULL) {\r
540 SHELL_FREE_NON_NULL(RetVal);\r
541 return NULL;\r
542 }\r
543 Temp2 = CatSPrint(RetVal, Temp, Attributes);\r
544 FreePool(Temp);\r
545 FreePool(RetVal);\r
546 RetVal = Temp2;\r
547 Temp2 = NULL;\r
548\r
549 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);\r
550 if (Temp == NULL) {\r
551 SHELL_FREE_NON_NULL(RetVal);\r
552 return NULL;\r
553 }\r
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
565 if (Temp == NULL) {\r
566 SHELL_FREE_NON_NULL(RetVal);\r
567 return NULL;\r
568 }\r
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
595 Temp2 = CatSPrint(RetVal,\r
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
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
642 HandleParsingHiiInit();\r
643\r
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
659 if (Temp != NULL) {\r
660 UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);\r
661 FreePool(Temp);\r
662 }\r
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
674 Temp == NULL?L"":Temp,\r
675 Index == Dev->Mode->Mode ? L'*' : L' ',\r
676 Index,\r
677 !EFI_ERROR(Status)?(INTN)Col:-1,\r
678 !EFI_ERROR(Status)?(INTN)Row:-1\r
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
715 RetVal = AllocateZeroPool(VersionStringSize);\r
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
742 Temp = NULL;\r
743\r
744 Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
745 if (!EFI_ERROR(Status)) {\r
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
751 }\r
752 if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {\r
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
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
784 CHAR16 *TempRetVal;\r
785 VOID *InformationBlock;\r
786 UINTN InformationBlockSize;\r
787\r
788 if (!Verbose) {\r
789 return (CatSPrint(NULL, L"AdapterInfo"));\r
790 }\r
791\r
792 InfoTypesBuffer = NULL;\r
793 InformationBlock = NULL;\r
794\r
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
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
814 &InfoTypesBuffer,\r
815 &InfoTypesBufferCount\r
816 );\r
817 RetVal = NULL;\r
818 if (EFI_ERROR (Status)) {\r
819 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED), NULL);\r
820 if (TempStr != NULL) {\r
821 RetVal = CatSPrint (NULL, TempStr, Status);\r
822 } else {\r
823 goto ERROR_EXIT;\r
824 }\r
825 } else {\r
826 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SUPP_TYPE_HEADER), NULL);\r
827 if (TempStr == NULL) {\r
828 goto ERROR_EXIT;\r
829 }\r
830 RetVal = CatSPrint (NULL, TempStr);\r
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
835 if (TempStr == NULL) {\r
836 goto ERROR_EXIT;\r
837 }\r
838 TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
839 SHELL_FREE_NON_NULL (RetVal);\r
840 RetVal = TempRetVal;\r
841 SHELL_FREE_NON_NULL (TempStr);\r
842\r
843 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
844 if (TempStr == NULL) {\r
845 goto ERROR_EXIT;\r
846 }\r
847\r
848 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
849 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
850 SHELL_FREE_NON_NULL (RetVal);\r
851 RetVal = TempRetVal;\r
852 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
853 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
854 SHELL_FREE_NON_NULL (RetVal);\r
855 RetVal = TempRetVal;\r
856 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
857 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
858 SHELL_FREE_NON_NULL (RetVal);\r
859 RetVal = TempRetVal;\r
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
864 } else {\r
865\r
866 GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
867\r
868 if (GuidStr != NULL) {\r
869 if (StrCmp(GuidStr, L"UnknownDevice") == 0) {\r
870 TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
871 SHELL_FREE_NON_NULL (RetVal);\r
872 RetVal = TempRetVal;\r
873\r
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
879 continue;\r
880 } else {\r
881 TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
882 SHELL_FREE_NON_NULL (RetVal);\r
883 RetVal = TempRetVal;\r
884 SHELL_FREE_NON_NULL(GuidStr);\r
885 }\r
886 }\r
887 }\r
888\r
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
900 if (TempStr == NULL) {\r
901 goto ERROR_EXIT;\r
902 }\r
903 TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
904 SHELL_FREE_NON_NULL (RetVal);\r
905 RetVal = TempRetVal;\r
906 } else {\r
907 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
908 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
909 if (TempStr == NULL) {\r
910 goto ERROR_EXIT;\r
911 }\r
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
920 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
921 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
922 if (TempStr == NULL) {\r
923 goto ERROR_EXIT;\r
924 }\r
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
940 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
941 if (TempStr == NULL) {\r
942 goto ERROR_EXIT;\r
943 }\r
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
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
969 } else {\r
970 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
971 if (TempStr == NULL) {\r
972 goto ERROR_EXIT;\r
973 }\r
974 TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
975 SHELL_FREE_NON_NULL (RetVal);\r
976 RetVal = TempRetVal;\r
977 }\r
978 }\r
979 SHELL_FREE_NON_NULL (TempStr);\r
980 SHELL_FREE_NON_NULL (InformationBlock);\r
981 }\r
982 }\r
983\r
984 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
985 return RetVal;\r
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
992}\r
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
1212 if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
1213 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
1214 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1215 AttributeSettingStr = TempRetVal;\r
1216 }\r
1217 if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
1218 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
1219 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1220 AttributeSettingStr = TempRetVal;\r
1221 }\r
1222 if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
1223 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
1224 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1225 AttributeSettingStr = TempRetVal;\r
1226 }\r
1227 if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
1228 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
1229 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1230 AttributeSettingStr = TempRetVal;\r
1231 }\r
1232 if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
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
1368 if (Found) {\r
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
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
1399 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
1400 }\r
1401\r
1402#define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \\r
1403 { \\r
1404 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
1405 }\r
1406\r
1407#define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \\r
1408 { \\r
1409 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
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
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
1421 }\r
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
1430STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {\r
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
1437STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
1438 {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation},\r
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
1463 {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation},\r
1464 {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, EdidDiscoveredProtocolDumpInformation},
1465 {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, EdidActiveProtocolDumpInformation},
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
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
1478 {STRING_TOKEN(STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation},\r
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
1509 {STRING_TOKEN(STR_IPV4_CFG2), &gEfiIp4Config2ProtocolGuid, NULL},\r
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
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
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
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
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
1589 {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, FirmwareManagementDumpInformation},\r
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
1599 {STRING_TOKEN(STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL},\r
1600\r
1601//\r
1602// UEFI 2.4\r
1603//\r
1604 {STRING_TOKEN(STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL},\r
1605 {STRING_TOKEN(STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, AdapterInformationDumpInformation},\r
1606\r
1607//\r
1608// PI Spec ones\r
1609//\r
1610 {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
1611 {STRING_TOKEN(STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL},\r
1612\r
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
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
1742//\r
1743// Misc\r
1744//\r
1745 {STRING_TOKEN(STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL},\r
1746\r
1747//\r
1748// terminator\r
1749//\r
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
1762CONST GUID_INFO_BLOCK *\r
1763EFIAPI\r
1764InternalShellGetNodeFromGuid(\r
1765 IN CONST EFI_GUID* Guid\r
1766 )\r
1767{\r
1768 CONST GUID_INFO_BLOCK *ListWalker;\r
1769 UINTN LoopCount;\r
1770\r
1771 ASSERT(Guid != NULL);\r
1772\r
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
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
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
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
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
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
1857 EFI_STRING_ID NameID;\r
1858\r
1859 HandleParsingHiiInit();\r
1860\r
1861 if (Guid == NULL || TheName == NULL){\r
1862 return (EFI_INVALID_PARAMETER);\r
1863 }\r
1864\r
1865 if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {\r
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
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
1895 CONST GUID_INFO_BLOCK *Id;\r
1896\r
1897 HandleParsingHiiInit();\r
1898\r
1899 Id = InternalShellGetNodeFromGuid(Guid);\r
1900 return (HiiGetString(mHandleParsingHiiHandle, Id==NULL?STRING_TOKEN(STR_UNKNOWN_DEVICE):Id->StringId, Lang));\r
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
1927 CONST GUID_INFO_BLOCK *Id;\r
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
1946 do not modify the returned Guid.\r
1947\r
1948 @param[in] Name The pointer to the string name.\r
1949 @param[in] Lang The pointer to the language code.\r
1950 @param[out] Guid The pointer to the Guid.\r
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
1959 OUT EFI_GUID **Guid\r
1960 )\r
1961{\r
1962 CONST GUID_INFO_BLOCK *ListWalker;\r
1963 CHAR16 *String;\r
1964 UINTN LoopCount;\r
1965\r
1966 HandleParsingHiiInit();\r
1967\r
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
1977 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
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
1988 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
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
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
2008 return (EFI_NOT_FOUND);\r
2009}\r
2010\r
2011/**\r
2012 Get best support language for this driver.\r
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
2016 support language list. The caller need to free the buffer of the best language.\r
2017\r
2018 @param[in] SupportedLanguages The support languages for this driver.\r
2019 @param[in] InputLanguage The user input language.\r
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
2025EFIAPI\r
2026GetBestLanguageForDriver (\r
2027 IN CONST CHAR8 *SupportedLanguages,\r
2028 IN CONST CHAR8 *InputLanguage,\r
2029 IN BOOLEAN Iso639Language\r
2030 )\r
2031{\r
2032 CHAR8 *LanguageVariable;\r
2033 CHAR8 *BestLanguage;\r
2034\r
2035 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);\r
2036\r
2037 BestLanguage = GetBestLanguage(\r
2038 SupportedLanguages,\r
2039 Iso639Language,\r
2040 (InputLanguage != NULL) ? InputLanguage : "",\r
2041 (LanguageVariable != NULL) ? LanguageVariable : "",\r
2042 SupportedLanguages,\r
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
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
2073 CHAR8 *BestLang;\r
2074\r
2075 BestLang = NULL;\r
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
2085 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2086 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
2087 if (BestLang != NULL) {\r
2088 FreePool (BestLang);\r
2089 BestLang = NULL;\r
2090 }\r
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
2103 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2104 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
2105 if (BestLang != NULL) {\r
2106 FreePool (BestLang);\r
2107 }\r
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
2149 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
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
2176 EFI_STATUS Status;\r
2177 EFI_GUID **ProtocolBuffer;\r
2178 UINTN ProtocolCount;\r
2179 HANDLE_LIST *ListWalker;\r
2180\r
2181 if (TheHandle == NULL) {\r
2182 return 0;\r
2183 }\r
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
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
2204 return (ListWalker->TheIndex);\r
2205 }\r
2206 }\r
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
2220 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
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
2245 EFI_STATUS Status;\r
2246 EFI_GUID **ProtocolBuffer;\r
2247 UINTN ProtocolCount;\r
2248 HANDLE_LIST *ListWalker;\r
2249\r
2250 InternalShellInitHandleList();\r
2251\r
2252 if (TheIndex >= mHandleList.NextIndex) {\r
2253 return NULL;\r
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
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
2271 return (ListWalker->TheHandle);\r
2272 }\r
2273 }\r
2274 return NULL;\r
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
2322 INTN DriverBindingHandleIndex;\r
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
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
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
2366 if (EFI_ERROR (Status)) {\r
2367 continue;\r
2368 }\r
2369\r
2370 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
2371\r
2372 //\r
2373 // Set the bit describing what this handle has\r
2374 //\r
2375 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
2376 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
2377 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
2378 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
2379 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
2380 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
2381 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
2382 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
2383 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
2384 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
2385 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
2386 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
2387 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
2388 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
2389 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
2390 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
2391 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
2392 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
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
2402 (*HandleBuffer)[HandleIndex],\r
2403 ProtocolGuidArray[ProtocolIndex],\r
2404 &OpenInfo,\r
2405 &OpenInfoCount\r
2406 );\r
2407 if (EFI_ERROR (Status)) {\r
2408 continue;\r
2409 }\r
2410\r
2411 if (ControllerHandle == NULL) {\r
2412 //\r
2413 // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
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
2418 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
2419 if (DriverBindingHandleIndex != -1) {\r
2420 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
2421 }\r
2422 }\r
2423 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2424 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
2425 if (DriverBindingHandleIndex != -1) {\r
2426 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
2427 }\r
2428 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2429 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
2430 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
2431 }\r
2432 }\r
2433 }\r
2434 }\r
2435 }\r
2436 if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
2437 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
2438 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
2439 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
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
2443 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
2444 }\r
2445 }\r
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
2450 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
2451 }\r
2452 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
2453 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
2454 }\r
2455 }\r
2456 }\r
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
2462 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
2463 }\r
2464 }\r
2465 }\r
2466 }\r
2467 }\r
2468 if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
2469 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
2470 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
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
2475 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
2476 }\r
2477 }\r
2478 }\r
2479 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2480 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
2481 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2482 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
2483 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
2484 }\r
2485 }\r
2486 }\r
2487\r
2488 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2489 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
2490 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
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
2499 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
2500 }\r
2501 }\r
2502 }\r
2503 }\r
2504 }\r
2505 FreePool (OpenInfo);\r
2506 }\r
2507 FreePool (ProtocolGuidArray);\r
2508 }\r
2509 return EFI_SUCCESS;\r
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
2607 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
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
2664 UINTN HandleIndex;\r
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
2671 EFI_HANDLE *HandleBufferForReturn;\r
2672\r
2673 if (MatchingHandleCount == NULL) {\r
2674 return (EFI_INVALID_PARAMETER);\r
2675 }\r
2676 *MatchingHandleCount = 0;\r
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
2687 //\r
2688 // Get a buffer big enough for all the controllers.\r
2689 //\r
2690 HandleBufferForReturn = GetHandleListByProtocol(NULL);\r
2691 if (HandleBufferForReturn == NULL) {\r
2692 FreePool (DriverBindingHandleBuffer);\r
2693 return (EFI_NOT_FOUND);\r
2694 }\r
2695\r
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
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
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
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
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
2782 *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);\r
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
2881GetHandleListByProtocol (\r
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
2898 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
2899 if (HandleList == NULL) {\r
2900 return (NULL);\r
2901 }\r
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
2908 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
2909 if (HandleList == NULL) {\r
2910 return (NULL);\r
2911 }\r
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
2931 @retval NULL ProtocolGuids was NULL.\r
2932 @return A NULL terminated list of EFI_HANDLEs.\r
2933**/\r
2934EFI_HANDLE*\r
2935EFIAPI\r
2936GetHandleListByProtocolList (\r
2937 IN CONST EFI_GUID **ProtocolGuids\r
2938 )\r
2939{\r
2940 EFI_HANDLE *HandleList;\r
2941 UINTN Size;\r
2942 UINTN TotalSize;\r
2943 UINTN TempSize;\r
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
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
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
2974 TempSize = TotalSize - Size;\r
2975 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));\r
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
2981 Size += TempSize;\r
2982 }\r
2983 }\r
2984 ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);\r
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