]> 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 comments
[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) 2013 - 2014, Hewlett-Packard Development Company, L.P.\r
5 Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>\r
6 This program and the accompanying materials\r
7 are licensed and made available under the terms and conditions of the BSD License\r
8 which accompanies this distribution. The full text of the license may be found at\r
9 http://opensource.org/licenses/bsd-license.php\r
10\r
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13\r
14**/\r
15\r
16#include "UefiHandleParsingLib.h"\r
17#include "IndustryStandard/Acpi10.h"\r
18\r
19EFI_HANDLE mHandleParsingHiiHandle;\r
20HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};\r
21\r
22/**\r
23 Function to translate the EFI_MEMORY_TYPE into a string.\r
24\r
25 @param[in] Memory The memory type.\r
26\r
27 @retval A string representation of the type allocated from BS Pool.\r
28**/\r
29CHAR16*\r
30EFIAPI\r
31ConvertMemoryType (\r
32 IN CONST EFI_MEMORY_TYPE Memory\r
33 )\r
34{\r
35 CHAR16 *RetVal;\r
36 RetVal = NULL;\r
37\r
38 switch (Memory) {\r
39 case EfiReservedMemoryType: StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0); break;\r
40 case EfiLoaderCode: StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0); break;\r
41 case EfiLoaderData: StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0); break;\r
42 case EfiBootServicesCode: StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0); break;\r
43 case EfiBootServicesData: StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0); break;\r
44 case EfiRuntimeServicesCode: StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0); break;\r
45 case EfiRuntimeServicesData: StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0); break;\r
46 case EfiConventionalMemory: StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0); break;\r
47 case EfiUnusableMemory: StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0); break;\r
48 case EfiACPIReclaimMemory: StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0); break;\r
49 case EfiACPIMemoryNVS: StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0); break;\r
50 case EfiMemoryMappedIO: StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0); break;\r
51 case EfiMemoryMappedIOPortSpace: StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0); break;\r
52 case EfiPalCode: StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0); break;\r
53 case EfiMaxMemoryType: StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0); break;\r
54 default: ASSERT(FALSE);\r
55 }\r
56 return (RetVal);\r
57}\r
58\r
59/**\r
60 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.\r
61\r
62 @param[in] Fmt The format type.\r
63\r
64 @retval A string representation of the type allocated from BS Pool.\r
65**/\r
66CHAR16*\r
67EFIAPI\r
68ConvertPixelFormat (\r
69 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt\r
70 )\r
71{\r
72 CHAR16 *RetVal;\r
73 RetVal = NULL;\r
74\r
75 switch (Fmt) {\r
76 case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0); break;\r
77 case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0); break;\r
78 case PixelBitMask: StrnCatGrow(&RetVal, NULL, L"PixelBitMask", 0); break;\r
79 case PixelBltOnly: StrnCatGrow(&RetVal, NULL, L"PixelBltOnly", 0); break;\r
80 case PixelFormatMax: StrnCatGrow(&RetVal, NULL, L"PixelFormatMax", 0); break;\r
81 default: ASSERT(FALSE);\r
82 }\r
83 return (RetVal);\r
84}\r
85\r
86/**\r
87 Constructor for the library.\r
88\r
89 @param[in] ImageHandle Ignored.\r
90 @param[in] SystemTable Ignored.\r
91\r
92 @retval EFI_SUCCESS The operation was successful.\r
93**/\r
94EFI_STATUS\r
95EFIAPI\r
96HandleParsingLibConstructor (\r
97 IN EFI_HANDLE ImageHandle,\r
98 IN EFI_SYSTEM_TABLE *SystemTable\r
99 )\r
100{\r
101 mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);\r
102 if (mHandleParsingHiiHandle == NULL) {\r
103 return (EFI_DEVICE_ERROR);\r
104 }\r
105\r
106 return (EFI_SUCCESS);\r
107}\r
108\r
109/**\r
110 Destructor for the library. free any resources.\r
111\r
112 @param[in] ImageHandle Ignored.\r
113 @param[in] SystemTable Ignored.\r
114\r
115 @retval EFI_SUCCESS The operation was successful.\r
116**/\r
117EFI_STATUS\r
118EFIAPI\r
119HandleParsingLibDestructor (\r
120 IN EFI_HANDLE ImageHandle,\r
121 IN EFI_SYSTEM_TABLE *SystemTable\r
122 )\r
123{\r
124 if (mHandleParsingHiiHandle != NULL) {\r
125 HiiRemovePackages(mHandleParsingHiiHandle);\r
126 }\r
127 return (EFI_SUCCESS);\r
128}\r
129\r
130/**\r
131 Function to dump information about LoadedImage.\r
132\r
133 This will allocate the return buffer from boot services pool.\r
134\r
135 @param[in] TheHandle The handle that has LoadedImage installed.\r
136 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
137\r
138 @retval A poitner to a string containing the information.\r
139**/\r
140CHAR16*\r
141EFIAPI\r
142LoadedImageProtocolDumpInformation(\r
143 IN CONST EFI_HANDLE TheHandle,\r
144 IN CONST BOOLEAN Verbose\r
145 )\r
146{\r
147 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
148 EFI_STATUS Status;\r
149 CHAR16 *RetVal;\r
150 CHAR16 *Temp;\r
151 CHAR16 *CodeType;\r
152 CHAR16 *DataType;\r
153\r
154 if (!Verbose) {\r
155 return (CatSPrint(NULL, L"LoadedImage"));\r
156 }\r
157\r
158 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);\r
159 RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));\r
160 if (Temp == NULL || RetVal == NULL) {\r
161 SHELL_FREE_NON_NULL(Temp);\r
162 SHELL_FREE_NON_NULL(RetVal);\r
163 return NULL;\r
164 }\r
165\r
166 Status = gBS->OpenProtocol (\r
167 TheHandle,\r
168 &gEfiLoadedImageProtocolGuid,\r
169 (VOID**)&LoadedImage,\r
170 gImageHandle,\r
171 NULL,\r
172 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
173 );\r
174\r
175 if (EFI_ERROR (Status)) {\r
176 SHELL_FREE_NON_NULL (Temp);\r
177 SHELL_FREE_NON_NULL (RetVal);\r
178 return NULL;\r
179 }\r
180\r
181 DataType = ConvertMemoryType(LoadedImage->ImageDataType);\r
182 CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);\r
183\r
184 RetVal = CatSPrint(RetVal,\r
185 Temp,\r
186 LoadedImage->Revision,\r
187 LoadedImage->ParentHandle,\r
188 LoadedImage->SystemTable,\r
189 LoadedImage->DeviceHandle,\r
190 LoadedImage->FilePath,\r
191 LoadedImage->LoadOptionsSize,\r
192 LoadedImage->LoadOptions,\r
193 LoadedImage->ImageBase,\r
194 LoadedImage->ImageSize,\r
195 CodeType,\r
196 DataType,\r
197 LoadedImage->Unload);\r
198\r
199 \r
200 SHELL_FREE_NON_NULL(Temp);\r
201 SHELL_FREE_NON_NULL(CodeType);\r
202 SHELL_FREE_NON_NULL(DataType);\r
203\r
204 return RetVal;\r
205}\r
206\r
207/**\r
208 Function to dump information about GOP.\r
209\r
210 This will allocate the return buffer from boot services pool.\r
211\r
212 @param[in] TheHandle The handle that has LoadedImage installed.\r
213 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
214\r
215 @retval A poitner to a string containing the information.\r
216**/\r
217CHAR16*\r
218EFIAPI\r
219GraphicsOutputProtocolDumpInformation(\r
220 IN CONST EFI_HANDLE TheHandle,\r
221 IN CONST BOOLEAN Verbose\r
222 )\r
223{\r
224 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;\r
225 EFI_STATUS Status;\r
226 CHAR16 *RetVal;\r
227 CHAR16 *Temp;\r
228 CHAR16 *Fmt;\r
229\r
230 if (!Verbose) {\r
231 return (CatSPrint(NULL, L"GraphicsOutput"));\r
232 }\r
233\r
234 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);\r
235 RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));\r
236 if (Temp == NULL || RetVal == NULL) {\r
237 SHELL_FREE_NON_NULL(Temp);\r
238 SHELL_FREE_NON_NULL(RetVal);\r
239 return NULL;\r
240 }\r
241\r
242 Status = gBS->OpenProtocol (\r
243 TheHandle,\r
244 &gEfiGraphicsOutputProtocolGuid,\r
245 (VOID**)&GraphicsOutput,\r
246 gImageHandle,\r
247 NULL,\r
248 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
249 );\r
250\r
251 if (EFI_ERROR (Status)) {\r
252 SHELL_FREE_NON_NULL (Temp);\r
253 SHELL_FREE_NON_NULL (RetVal);\r
254 return NULL;\r
255 }\r
256\r
257 Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);\r
258\r
259 RetVal = CatSPrint(RetVal,\r
260 Temp,\r
261 GraphicsOutput->Mode->MaxMode,\r
262 GraphicsOutput->Mode->Mode,\r
263 GraphicsOutput->Mode->FrameBufferBase,\r
264 (UINT64)GraphicsOutput->Mode->FrameBufferSize,\r
265 (UINT64)GraphicsOutput->Mode->SizeOfInfo,\r
266 GraphicsOutput->Mode->Info->Version,\r
267 GraphicsOutput->Mode->Info->HorizontalResolution,\r
268 GraphicsOutput->Mode->Info->VerticalResolution,\r
269 Fmt,\r
270 GraphicsOutput->Mode->Info->PixelsPerScanLine,\r
271 GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.RedMask,\r
272 GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.GreenMask,\r
273 GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask\r
274 );\r
275 \r
276 SHELL_FREE_NON_NULL(Temp);\r
277 SHELL_FREE_NON_NULL(Fmt);\r
278\r
279 return RetVal;\r
280}\r
281\r
282/**\r
283 Function to dump information about PciRootBridgeIo.\r
284\r
285 This will allocate the return buffer from boot services pool.\r
286\r
287 @param[in] TheHandle The handle that has PciRootBridgeIo installed.\r
288 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
289\r
290 @retval A poitner to a string containing the information.\r
291**/\r
292CHAR16*\r
293EFIAPI\r
294PciRootBridgeIoDumpInformation(\r
295 IN CONST EFI_HANDLE TheHandle,\r
296 IN CONST BOOLEAN Verbose\r
297 )\r
298{\r
299 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;\r
300 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;\r
301 UINT64 Supports;\r
302 UINT64 Attributes;\r
303 CHAR16 *Temp;\r
304 CHAR16 *Temp2;\r
305 CHAR16 *RetVal;\r
306 EFI_STATUS Status;\r
307\r
308 RetVal = NULL;\r
309\r
310 if (!Verbose) {\r
311 return (CatSPrint(NULL, L"PciRootBridgeIo"));\r
312 }\r
313\r
314 Status = gBS->HandleProtocol(\r
315 TheHandle,\r
316 &gEfiPciRootBridgeIoProtocolGuid,\r
317 (VOID**)&PciRootBridgeIo);\r
318\r
319 if (EFI_ERROR(Status)) {\r
320 return NULL;\r
321 }\r
322\r
323 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_PH), NULL);\r
324 ASSERT (Temp != NULL);\r
325 Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);\r
326 FreePool(Temp);\r
327 RetVal = Temp2;\r
328 Temp2 = NULL;\r
329 \r
330 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);\r
331 ASSERT (Temp != NULL);\r
332 Temp2 = CatSPrint(RetVal, Temp, PciRootBridgeIo->SegmentNumber);\r
333 FreePool(Temp);\r
334 FreePool(RetVal);\r
335 RetVal = Temp2;\r
336 Temp2 = NULL;\r
337\r
338 Supports = 0;\r
339 Attributes = 0;\r
340 Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);\r
341 if (!EFI_ERROR(Status)) {\r
342 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_ATT), NULL);\r
343 ASSERT (Temp != NULL); \r
344 Temp2 = CatSPrint(RetVal, Temp, Attributes);\r
345 FreePool(Temp);\r
346 FreePool(RetVal);\r
347 RetVal = Temp2;\r
348 Temp2 = NULL;\r
349 \r
350 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);\r
351 ASSERT (Temp != NULL);\r
352 Temp2 = CatSPrint(RetVal, Temp, Supports);\r
353 FreePool(Temp);\r
354 FreePool(RetVal);\r
355 RetVal = Temp2;\r
356 Temp2 = NULL;\r
357 }\r
358\r
359 Configuration = NULL;\r
360 Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);\r
361 if (!EFI_ERROR(Status) && Configuration != NULL) {\r
362 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_TITLE), NULL);\r
363 ASSERT (Temp != NULL);\r
364 Temp2 = CatSPrint(RetVal, Temp, Supports);\r
365 FreePool(Temp);\r
366 FreePool(RetVal);\r
367 RetVal = Temp2;\r
368 Temp2 = NULL;\r
369 while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {\r
370 Temp = NULL;\r
371 switch (Configuration->ResType) {\r
372 case ACPI_ADDRESS_SPACE_TYPE_MEM:\r
373 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_MEM), NULL);\r
374 break;\r
375 case ACPI_ADDRESS_SPACE_TYPE_IO:\r
376 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_IO), NULL);\r
377 break;\r
378 case ACPI_ADDRESS_SPACE_TYPE_BUS:\r
379 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_BUS), NULL);\r
380 break;\r
381 }\r
382 if (Temp != NULL) {\r
383 Temp2 = CatSPrint(RetVal, L"%s", Temp);\r
384 FreePool(Temp);\r
385 FreePool(RetVal);\r
386 RetVal = Temp2;\r
387 Temp2 = NULL;\r
388 }\r
389\r
390 Temp2 = CatSPrint(RetVal, \r
391 L"%H%02x %016lx %016lx %02x%N\r\n",\r
392 Configuration->SpecificFlag,\r
393 Configuration->AddrRangeMin,\r
394 Configuration->AddrRangeMax,\r
395 Configuration->AddrSpaceGranularity\r
396 );\r
397 FreePool(RetVal);\r
398 RetVal = Temp2;\r
399 Temp2 = NULL;\r
400 Configuration++;\r
401 }\r
402 }\r
403 return (RetVal);\r
404}\r
405\r
406/**\r
407 Function to dump information about SimpleTextOut.\r
408\r
409 This will allocate the return buffer from boot services pool.\r
410\r
411 @param[in] TheHandle The handle that has SimpleTextOut installed.\r
412 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
413\r
414 @retval A poitner to a string containing the information.\r
415**/\r
416CHAR16*\r
417EFIAPI\r
418TxtOutProtocolDumpInformation(\r
419 IN CONST EFI_HANDLE TheHandle,\r
420 IN CONST BOOLEAN Verbose\r
421 )\r
422{\r
423 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Dev;\r
424 INTN Index;\r
425 UINTN Col;\r
426 UINTN Row;\r
427 EFI_STATUS Status;\r
428 CHAR16 *RetVal;\r
429 UINTN Size;\r
430 CHAR16 *Temp;\r
431 UINTN NewSize;\r
432\r
433 if (!Verbose) {\r
434 return (NULL);\r
435 }\r
436\r
437 RetVal = NULL;\r
438 Size = 0;\r
439\r
440 Status = gBS->HandleProtocol(\r
441 TheHandle,\r
442 &gEfiSimpleTextOutProtocolGuid,\r
443 (VOID**)&Dev);\r
444\r
445 ASSERT_EFI_ERROR(Status);\r
446 ASSERT (Dev != NULL && Dev->Mode != NULL);\r
447\r
448 Size = (Dev->Mode->MaxMode + 1) * 80;\r
449 RetVal = AllocateZeroPool(Size);\r
450\r
451 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER), NULL);\r
452 if (Temp != NULL) {\r
453 UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);\r
454 FreePool(Temp);\r
455 }\r
456\r
457 //\r
458 // Dump TextOut Info\r
459 //\r
460 Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE), NULL);\r
461 for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {\r
462 Status = Dev->QueryMode (Dev, Index, &Col, &Row);\r
463 NewSize = Size - StrSize(RetVal);\r
464 UnicodeSPrint(\r
465 RetVal + StrLen(RetVal),\r
466 NewSize,\r
467 Temp == NULL?L"":Temp,\r
468 Index == Dev->Mode->Mode ? L'*' : L' ',\r
469 Index,\r
470 !EFI_ERROR(Status)?(INTN)Col:-1,\r
471 !EFI_ERROR(Status)?(INTN)Row:-1\r
472 );\r
473 }\r
474 FreePool(Temp);\r
475 return (RetVal);\r
476}\r
477\r
478STATIC CONST UINTN VersionStringSize = 60;\r
479\r
480/**\r
481 Function to dump information about EfiDriverSupportedEfiVersion protocol.\r
482\r
483 This will allocate the return buffer from boot services pool.\r
484\r
485 @param[in] TheHandle The handle that has the protocol installed.\r
486 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
487\r
488 @retval A poitner to a string containing the information.\r
489**/\r
490CHAR16*\r
491EFIAPI\r
492DriverEfiVersionProtocolDumpInformation(\r
493 IN CONST EFI_HANDLE TheHandle,\r
494 IN CONST BOOLEAN Verbose\r
495 )\r
496{\r
497 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;\r
498 EFI_STATUS Status;\r
499 CHAR16 *RetVal;\r
500\r
501 Status = gBS->HandleProtocol(\r
502 TheHandle,\r
503 &gEfiDriverSupportedEfiVersionProtocolGuid,\r
504 (VOID**)&DriverEfiVersion);\r
505\r
506 ASSERT_EFI_ERROR(Status);\r
507\r
508 RetVal = AllocateZeroPool(VersionStringSize);\r
509 ASSERT(RetVal != NULL);\r
510 UnicodeSPrint(RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
511 return (RetVal);\r
512}\r
513\r
514/**\r
515 Function to dump information about DevicePath protocol.\r
516\r
517 This will allocate the return buffer from boot services pool.\r
518\r
519 @param[in] TheHandle The handle that has the protocol installed.\r
520 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
521\r
522 @retval A poitner to a string containing the information.\r
523**/\r
524CHAR16*\r
525EFIAPI\r
526DevicePathProtocolDumpInformation(\r
527 IN CONST EFI_HANDLE TheHandle,\r
528 IN CONST BOOLEAN Verbose\r
529 )\r
530{\r
531 EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
532 CHAR16 *Temp;\r
533 CHAR16 *Temp2;\r
534 EFI_STATUS Status;\r
535 Temp = NULL;\r
536\r
537 Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
538 if (!EFI_ERROR(Status)) {\r
539 //\r
540 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
541 //\r
542 Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);\r
543 gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);\r
544 }\r
545 if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {\r
546 Temp2 = NULL;\r
547 Temp2 = StrnCatGrow(&Temp2, NULL, Temp+(StrLen(Temp) - 30), 30);\r
548 FreePool(Temp);\r
549 Temp = Temp2;\r
550 }\r
551 return (Temp);\r
552}\r
553\r
554//\r
555// Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg\r
556//\r
557#define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \\r
558 { \\r
559 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
560 }\r
561\r
562#define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \\r
563 { \\r
564 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
565 }\r
566\r
567#define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \\r
568 { \\r
569 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
570 }\r
571STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;\r
572STATIC CONST EFI_GUID WinNtIoProtocolGuid = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;\r
573STATIC CONST EFI_GUID WinNtSerialPortGuid = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;\r
574\r
575STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {\r
576 {STRING_TOKEN(STR_WINNT_THUNK), (EFI_GUID*)&WinNtThunkProtocolGuid, NULL},\r
577 {STRING_TOKEN(STR_WINNT_DRIVER_IO), (EFI_GUID*)&WinNtIoProtocolGuid, NULL},\r
578 {STRING_TOKEN(STR_WINNT_SERIAL_PORT), (EFI_GUID*)&WinNtSerialPortGuid, NULL},\r
579 {STRING_TOKEN(STR_UNKNOWN_DEVICE), NULL, NULL},\r
580};\r
581\r
582STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
583 {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation},\r
584 {STRING_TOKEN(STR_DEVICE_PATH), &gEfiDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
585 {STRING_TOKEN(STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
586 {STRING_TOKEN(STR_DEVICE_PATH_UTIL), &gEfiDevicePathUtilitiesProtocolGuid, NULL},\r
587 {STRING_TOKEN(STR_DEVICE_PATH_TXT), &gEfiDevicePathToTextProtocolGuid, NULL},\r
588 {STRING_TOKEN(STR_DEVICE_PATH_FTXT), &gEfiDevicePathFromTextProtocolGuid, NULL},\r
589 {STRING_TOKEN(STR_DEVICE_PATH_PC), &gEfiPcAnsiGuid, NULL},\r
590 {STRING_TOKEN(STR_DEVICE_PATH_VT100), &gEfiVT100Guid, NULL},\r
591 {STRING_TOKEN(STR_DEVICE_PATH_VT100P), &gEfiVT100PlusGuid, NULL},\r
592 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8), &gEfiVTUTF8Guid, NULL},\r
593 {STRING_TOKEN(STR_DRIVER_BINDING), &gEfiDriverBindingProtocolGuid, NULL},\r
594 {STRING_TOKEN(STR_PLATFORM_OVERRIDE), &gEfiPlatformDriverOverrideProtocolGuid, NULL},\r
595 {STRING_TOKEN(STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, NULL},\r
596 {STRING_TOKEN(STR_DRIVER_DIAG), &gEfiDriverDiagnosticsProtocolGuid, NULL},\r
597 {STRING_TOKEN(STR_DRIVER_DIAG2), &gEfiDriverDiagnostics2ProtocolGuid, NULL},\r
598 {STRING_TOKEN(STR_DRIVER_CN), &gEfiComponentNameProtocolGuid, NULL},\r
599 {STRING_TOKEN(STR_DRIVER_CN2), &gEfiComponentName2ProtocolGuid, NULL},\r
600 {STRING_TOKEN(STR_PLAT_DRV_CFG), &gEfiPlatformToDriverConfigurationProtocolGuid, NULL},\r
601 {STRING_TOKEN(STR_DRIVER_VERSION), &gEfiDriverSupportedEfiVersionProtocolGuid, DriverEfiVersionProtocolDumpInformation},\r
602 {STRING_TOKEN(STR_TXT_IN), &gEfiSimpleTextInProtocolGuid, NULL},\r
603 {STRING_TOKEN(STR_TXT_IN_EX), &gEfiSimpleTextInputExProtocolGuid, NULL},\r
604 {STRING_TOKEN(STR_TXT_OUT), &gEfiSimpleTextOutProtocolGuid, TxtOutProtocolDumpInformation},\r
605 {STRING_TOKEN(STR_SIM_POINTER), &gEfiSimplePointerProtocolGuid, NULL},\r
606 {STRING_TOKEN(STR_ABS_POINTER), &gEfiAbsolutePointerProtocolGuid, NULL},\r
607 {STRING_TOKEN(STR_SERIAL_IO), &gEfiSerialIoProtocolGuid, NULL},\r
608 {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation},\r
609 {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, NULL},\r
610 {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, NULL},\r
611 {STRING_TOKEN(STR_EDID_OVERRIDE), &gEfiEdidOverrideProtocolGuid, NULL},\r
612 {STRING_TOKEN(STR_CON_IN), &gEfiConsoleInDeviceGuid, NULL},\r
613 {STRING_TOKEN(STR_CON_OUT), &gEfiConsoleOutDeviceGuid, NULL},\r
614 {STRING_TOKEN(STR_STD_ERR), &gEfiStandardErrorDeviceGuid, NULL},\r
615 {STRING_TOKEN(STR_LOAD_FILE), &gEfiLoadFileProtocolGuid, NULL},\r
616 {STRING_TOKEN(STR_LOAD_FILE2), &gEfiLoadFile2ProtocolGuid, NULL},\r
617 {STRING_TOKEN(STR_SIMPLE_FILE_SYS), &gEfiSimpleFileSystemProtocolGuid, NULL},\r
618 {STRING_TOKEN(STR_TAPE_IO), &gEfiTapeIoProtocolGuid, NULL},\r
619 {STRING_TOKEN(STR_DISK_IO), &gEfiDiskIoProtocolGuid, NULL},\r
620 {STRING_TOKEN(STR_BLK_IO), &gEfiBlockIoProtocolGuid, NULL},\r
621 {STRING_TOKEN(STR_UC), &gEfiUnicodeCollationProtocolGuid, NULL},\r
622 {STRING_TOKEN(STR_UC2), &gEfiUnicodeCollation2ProtocolGuid, NULL},\r
623 {STRING_TOKEN(STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation},\r
624 {STRING_TOKEN(STR_PCI_IO), &gEfiPciIoProtocolGuid, NULL},\r
625 {STRING_TOKEN(STR_SCSI_PT), &gEfiScsiPassThruProtocolGuid, NULL},\r
626 {STRING_TOKEN(STR_SCSI_IO), &gEfiScsiIoProtocolGuid, NULL},\r
627 {STRING_TOKEN(STR_SCSI_PT_EXT), &gEfiExtScsiPassThruProtocolGuid, NULL},\r
628 {STRING_TOKEN(STR_ISCSI), &gEfiIScsiInitiatorNameProtocolGuid, NULL},\r
629 {STRING_TOKEN(STR_USB_IO), &gEfiUsbIoProtocolGuid, NULL},\r
630 {STRING_TOKEN(STR_USB_HC), &gEfiUsbHcProtocolGuid, NULL},\r
631 {STRING_TOKEN(STR_USB_HC2), &gEfiUsb2HcProtocolGuid, NULL},\r
632 {STRING_TOKEN(STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, NULL},\r
633 {STRING_TOKEN(STR_DEBUG_PORT), &gEfiDebugPortProtocolGuid, NULL},\r
634 {STRING_TOKEN(STR_DECOMPRESS), &gEfiDecompressProtocolGuid, NULL},\r
635 {STRING_TOKEN(STR_ACPI_TABLE), &gEfiAcpiTableProtocolGuid, NULL},\r
636 {STRING_TOKEN(STR_EBC_INTERPRETER), &gEfiEbcProtocolGuid, NULL},\r
637 {STRING_TOKEN(STR_SNP), &gEfiSimpleNetworkProtocolGuid, NULL},\r
638 {STRING_TOKEN(STR_NII), &gEfiNetworkInterfaceIdentifierProtocolGuid, NULL},\r
639 {STRING_TOKEN(STR_NII_31), &gEfiNetworkInterfaceIdentifierProtocolGuid_31, NULL},\r
640 {STRING_TOKEN(STR_PXE_BC), &gEfiPxeBaseCodeProtocolGuid, NULL},\r
641 {STRING_TOKEN(STR_PXE_CB), &gEfiPxeBaseCodeCallbackProtocolGuid, NULL},\r
642 {STRING_TOKEN(STR_BIS), &gEfiBisProtocolGuid, NULL},\r
643 {STRING_TOKEN(STR_MNP_SB), &gEfiManagedNetworkServiceBindingProtocolGuid, NULL},\r
644 {STRING_TOKEN(STR_MNP), &gEfiManagedNetworkProtocolGuid, NULL},\r
645 {STRING_TOKEN(STR_ARP_SB), &gEfiArpServiceBindingProtocolGuid, NULL},\r
646 {STRING_TOKEN(STR_ARP), &gEfiArpProtocolGuid, NULL},\r
647 {STRING_TOKEN(STR_DHCPV4_SB), &gEfiDhcp4ServiceBindingProtocolGuid, NULL},\r
648 {STRING_TOKEN(STR_DHCPV4), &gEfiDhcp4ProtocolGuid, NULL},\r
649 {STRING_TOKEN(STR_TCPV4_SB), &gEfiTcp4ServiceBindingProtocolGuid, NULL},\r
650 {STRING_TOKEN(STR_TCPV4), &gEfiTcp4ProtocolGuid, NULL},\r
651 {STRING_TOKEN(STR_IPV4_SB), &gEfiIp4ServiceBindingProtocolGuid, NULL},\r
652 {STRING_TOKEN(STR_IPV4), &gEfiIp4ProtocolGuid, NULL},\r
653 {STRING_TOKEN(STR_IPV4_CFG), &gEfiIp4ConfigProtocolGuid, NULL},\r
654 {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
655 {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
656 {STRING_TOKEN(STR_UDPV4_SB), &gEfiUdp4ServiceBindingProtocolGuid, NULL},\r
657 {STRING_TOKEN(STR_UDPV4), &gEfiUdp4ProtocolGuid, NULL},\r
658 {STRING_TOKEN(STR_MTFTPV4_SB), &gEfiMtftp4ServiceBindingProtocolGuid, NULL},\r
659 {STRING_TOKEN(STR_MTFTPV4), &gEfiMtftp4ProtocolGuid, NULL},\r
660 {STRING_TOKEN(STR_AUTH_INFO), &gEfiAuthenticationInfoProtocolGuid, NULL},\r
661 {STRING_TOKEN(STR_HASH_SB), &gEfiHashServiceBindingProtocolGuid, NULL},\r
662 {STRING_TOKEN(STR_HASH), &gEfiHashProtocolGuid, NULL},\r
663 {STRING_TOKEN(STR_HII_FONT), &gEfiHiiFontProtocolGuid, NULL},\r
664 {STRING_TOKEN(STR_HII_STRING), &gEfiHiiStringProtocolGuid, NULL},\r
665 {STRING_TOKEN(STR_HII_IMAGE), &gEfiHiiImageProtocolGuid, NULL},\r
666 {STRING_TOKEN(STR_HII_DATABASE), &gEfiHiiDatabaseProtocolGuid, NULL},\r
667 {STRING_TOKEN(STR_HII_CONFIG_ROUT), &gEfiHiiConfigRoutingProtocolGuid, NULL},\r
668 {STRING_TOKEN(STR_HII_CONFIG_ACC), &gEfiHiiConfigAccessProtocolGuid, NULL},\r
669 {STRING_TOKEN(STR_HII_FORM_BROWSER2), &gEfiFormBrowser2ProtocolGuid, NULL},\r
670 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE), &gEfiDriverFamilyOverrideProtocolGuid, NULL},\r
671 {STRING_TOKEN(STR_PCD), &gPcdProtocolGuid, NULL},\r
672 {STRING_TOKEN(STR_TCG), &gEfiTcgProtocolGuid, NULL},\r
673 {STRING_TOKEN(STR_HII_PACKAGE_LIST), &gEfiHiiPackageListProtocolGuid, NULL},\r
674\r
675//\r
676// the ones under this are deprecated by the current UEFI Spec, but may be found anyways...\r
677//\r
678 {STRING_TOKEN(STR_SHELL_INTERFACE), &gEfiShellInterfaceGuid, NULL},\r
679 {STRING_TOKEN(STR_SHELL_ENV2), &gEfiShellEnvironment2Guid, NULL},\r
680 {STRING_TOKEN(STR_SHELL_ENV), &gEfiShellEnvironment2Guid, NULL},\r
681 {STRING_TOKEN(STR_DEVICE_IO), &gEfiDeviceIoProtocolGuid, NULL},\r
682 {STRING_TOKEN(STR_UGA_DRAW), &gEfiUgaDrawProtocolGuid, NULL},\r
683 {STRING_TOKEN(STR_UGA_IO), &gEfiUgaIoProtocolGuid, NULL},\r
684 {STRING_TOKEN(STR_ESP), &gEfiPartTypeSystemPartGuid, NULL},\r
685 {STRING_TOKEN(STR_GPT_NBR), &gEfiPartTypeLegacyMbrGuid, NULL},\r
686 {STRING_TOKEN(STR_DRIVER_CONFIG), &gEfiDriverConfigurationProtocolGuid, NULL},\r
687 {STRING_TOKEN(STR_DRIVER_CONFIG2), &gEfiDriverConfiguration2ProtocolGuid, NULL},\r
688\r
689//\r
690// the ones under this are GUID identified structs, not protocols\r
691//\r
692 {STRING_TOKEN(STR_FILE_INFO), &gEfiFileInfoGuid, NULL},\r
693 {STRING_TOKEN(STR_FILE_SYS_INFO), &gEfiFileSystemInfoGuid, NULL},\r
694\r
695//\r
696// the ones under this are misc GUIDS.\r
697//\r
698 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE), &gEfiGlobalVariableGuid, NULL},\r
699\r
700//\r
701// UEFI 2.2\r
702//\r
703 {STRING_TOKEN(STR_IP6_SB), &gEfiIp6ServiceBindingProtocolGuid, NULL},\r
704 {STRING_TOKEN(STR_IP6), &gEfiIp6ProtocolGuid, NULL},\r
705 {STRING_TOKEN(STR_IP6_CONFIG), &gEfiIp6ConfigProtocolGuid, NULL},\r
706 {STRING_TOKEN(STR_MTFTP6_SB), &gEfiMtftp6ServiceBindingProtocolGuid, NULL},\r
707 {STRING_TOKEN(STR_MTFTP6), &gEfiMtftp6ProtocolGuid, NULL},\r
708 {STRING_TOKEN(STR_DHCP6_SB), &gEfiDhcp6ServiceBindingProtocolGuid, NULL},\r
709 {STRING_TOKEN(STR_DHCP6), &gEfiDhcp6ProtocolGuid, NULL},\r
710 {STRING_TOKEN(STR_UDP6_SB), &gEfiUdp6ServiceBindingProtocolGuid, NULL},\r
711 {STRING_TOKEN(STR_UDP6), &gEfiUdp6ProtocolGuid, NULL},\r
712 {STRING_TOKEN(STR_TCP6_SB), &gEfiTcp6ServiceBindingProtocolGuid, NULL},\r
713 {STRING_TOKEN(STR_TCP6), &gEfiTcp6ProtocolGuid, NULL},\r
714 {STRING_TOKEN(STR_VLAN_CONFIG), &gEfiVlanConfigProtocolGuid, NULL},\r
715 {STRING_TOKEN(STR_EAP), &gEfiEapProtocolGuid, NULL},\r
716 {STRING_TOKEN(STR_EAP_MGMT), &gEfiEapManagementProtocolGuid, NULL},\r
717 {STRING_TOKEN(STR_FTP4_SB), &gEfiFtp4ServiceBindingProtocolGuid, NULL},\r
718 {STRING_TOKEN(STR_FTP4), &gEfiFtp4ProtocolGuid, NULL},\r
719 {STRING_TOKEN(STR_IP_SEC_CONFIG), &gEfiIpSecConfigProtocolGuid, NULL},\r
720 {STRING_TOKEN(STR_DH), &gEfiDriverHealthProtocolGuid, NULL},\r
721 {STRING_TOKEN(STR_DEF_IMG_LOAD), &gEfiDeferredImageLoadProtocolGuid, NULL},\r
722 {STRING_TOKEN(STR_USER_CRED), &gEfiUserCredentialProtocolGuid, NULL},\r
723 {STRING_TOKEN(STR_USER_MNGR), &gEfiUserManagerProtocolGuid, NULL},\r
724 {STRING_TOKEN(STR_ATA_PASS_THRU), &gEfiAtaPassThruProtocolGuid, NULL},\r
725\r
726//\r
727// UEFI 2.3\r
728//\r
729 {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, NULL},\r
730 {STRING_TOKEN(STR_IP_SEC), &gEfiIpSecProtocolGuid, NULL},\r
731 {STRING_TOKEN(STR_IP_SEC2), &gEfiIpSec2ProtocolGuid, NULL},\r
732\r
733//\r
734// UEFI 2.3.1\r
735//\r
736 {STRING_TOKEN(STR_KMS), &gEfiKmsProtocolGuid, NULL},\r
737 {STRING_TOKEN(STR_BLK_IO2), &gEfiBlockIo2ProtocolGuid, NULL},\r
738 {STRING_TOKEN(STR_SSC), &gEfiStorageSecurityCommandProtocolGuid, NULL},\r
739 {STRING_TOKEN(STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL},\r
740\r
741//\r
742// UEFI 2.4\r
743//\r
744 {STRING_TOKEN(STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL},\r
745 {STRING_TOKEN(STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, NULL},\r
746\r
747//\r
748// PI Spec ones\r
749//\r
750 {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
751\r
752//\r
753// terminator\r
754//\r
755 {STRING_TOKEN(STR_UNKNOWN_DEVICE), NULL, NULL},\r
756};\r
757\r
758/**\r
759 Function to get the node for a protocol or struct from it's GUID.\r
760\r
761 if Guid is NULL, then ASSERT.\r
762\r
763 @param[in] Guid The GUID to look for the name of.\r
764\r
765 @return The node.\r
766**/\r
767CONST GUID_INFO_BLOCK *\r
768EFIAPI\r
769InternalShellGetNodeFromGuid(\r
770 IN CONST EFI_GUID* Guid\r
771 )\r
772{\r
773 CONST GUID_INFO_BLOCK *ListWalker;\r
774\r
775 ASSERT(Guid != NULL);\r
776\r
777 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
778 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
779 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
780 return (ListWalker);\r
781 }\r
782 }\r
783 }\r
784 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
785 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
786 return (ListWalker);\r
787 }\r
788 }\r
789 return (ListWalker);\r
790}\r
791\r
792/**\r
793 Function to get the name of a protocol or struct from it's GUID.\r
794\r
795 if Guid is NULL, then ASSERT.\r
796\r
797 @param[in] Guid The GUID to look for the name of.\r
798 @param[in] Lang The language to use.\r
799\r
800 @return pointer to string of the name. The caller\r
801 is responsible to free this memory.\r
802**/\r
803CHAR16*\r
804EFIAPI\r
805GetStringNameFromGuid(\r
806 IN CONST EFI_GUID *Guid,\r
807 IN CONST CHAR8 *Lang OPTIONAL\r
808 )\r
809{\r
810 CONST GUID_INFO_BLOCK *Id;\r
811\r
812 Id = InternalShellGetNodeFromGuid(Guid);\r
813 return (HiiGetString(mHandleParsingHiiHandle, Id->StringId, Lang));\r
814}\r
815\r
816/**\r
817 Function to dump protocol information from a handle.\r
818\r
819 This function will return a allocated string buffer containing the\r
820 information. The caller is responsible for freeing the memory.\r
821\r
822 If Guid is NULL, ASSERT().\r
823 If TheHandle is NULL, ASSERT().\r
824\r
825 @param[in] TheHandle The handle to dump information from.\r
826 @param[in] Guid The GUID of the protocol to dump.\r
827 @param[in] Verbose TRUE for extra info. FALSE otherwise.\r
828\r
829 @return The pointer to string.\r
830 @retval NULL An error was encountered.\r
831**/\r
832CHAR16*\r
833EFIAPI\r
834GetProtocolInformationDump(\r
835 IN CONST EFI_HANDLE TheHandle,\r
836 IN CONST EFI_GUID *Guid,\r
837 IN CONST BOOLEAN Verbose\r
838 )\r
839{\r
840 CONST GUID_INFO_BLOCK *Id;\r
841\r
842 ASSERT(TheHandle != NULL);\r
843 ASSERT(Guid != NULL);\r
844\r
845 if (TheHandle == NULL || Guid == NULL) {\r
846 return (NULL);\r
847 }\r
848\r
849 Id = InternalShellGetNodeFromGuid(Guid);\r
850 if (Id != NULL && Id->DumpInfo != NULL) {\r
851 return (Id->DumpInfo(TheHandle, Verbose));\r
852 }\r
853 return (NULL);\r
854}\r
855\r
856/**\r
857 Function to get the Guid for a protocol or struct based on it's string name.\r
858\r
859 @param[in] Name The pointer to the string name.\r
860 @param[in] Lang The pointer to the language code.\r
861 @param[in] Guid The pointer to the Guid.\r
862\r
863 @retval EFI_SUCCESS The operation was sucessful.\r
864**/\r
865EFI_STATUS\r
866EFIAPI\r
867GetGuidFromStringName(\r
868 IN CONST CHAR16 *Name,\r
869 IN CONST CHAR8 *Lang OPTIONAL,\r
870 IN EFI_GUID **Guid\r
871 )\r
872{\r
873 CONST GUID_INFO_BLOCK *ListWalker;\r
874 CHAR16 *String;\r
875\r
876 ASSERT(Guid != NULL);\r
877 if (Guid == NULL) {\r
878 return (EFI_INVALID_PARAMETER);\r
879 }\r
880 *Guid = NULL;\r
881\r
882 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
883 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
884 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
885 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
886 *Guid = ListWalker->GuidId;\r
887 }\r
888 SHELL_FREE_NON_NULL(String);\r
889 if (*Guid != NULL) {\r
890 return (EFI_SUCCESS);\r
891 }\r
892 }\r
893 }\r
894 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
895 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
896 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
897 *Guid = ListWalker->GuidId;\r
898 }\r
899 SHELL_FREE_NON_NULL(String);\r
900 if (*Guid != NULL) {\r
901 return (EFI_SUCCESS);\r
902 }\r
903 }\r
904 return (EFI_NOT_FOUND);\r
905}\r
906\r
907/**\r
908 Get best support language for this driver.\r
909 \r
910 First base on the user input language to search, second base on the current \r
911 platform used language to search, third get the first language from the \r
912 support language list. The caller need to free the buffer of the best language.\r
913\r
914 @param[in] SupportedLanguages The support languages for this driver.\r
915 @param[in] InputLanguage The user input language.\r
916 @param[in] Iso639Language Whether get language for ISO639.\r
917\r
918 @return The best support language for this driver.\r
919**/\r
920CHAR8 *\r
921EFIAPI\r
922GetBestLanguageForDriver (\r
923 IN CONST CHAR8 *SupportedLanguages,\r
924 IN CONST CHAR8 *InputLanguage,\r
925 IN BOOLEAN Iso639Language\r
926 )\r
927{\r
928 CHAR8 *LanguageVariable;\r
929 CHAR8 *BestLanguage;\r
930\r
931 LanguageVariable = GetVariable (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid);\r
932\r
933 BestLanguage = GetBestLanguage(\r
934 SupportedLanguages,\r
935 Iso639Language,\r
936 (InputLanguage != NULL) ? InputLanguage : "",\r
937 (LanguageVariable != NULL) ? LanguageVariable : "",\r
938 SupportedLanguages,\r
939 NULL\r
940 );\r
941\r
942 if (LanguageVariable != NULL) {\r
943 FreePool (LanguageVariable);\r
944 }\r
945\r
946 return BestLanguage;\r
947}\r
948\r
949/**\r
950 Function to retrieve the driver name (if possible) from the ComponentName or\r
951 ComponentName2 protocol\r
952\r
953 @param[in] TheHandle The driver handle to get the name of.\r
954 @param[in] Language The language to use.\r
955\r
956 @retval NULL The name could not be found.\r
957 @return A pointer to the string name. Do not de-allocate the memory.\r
958**/\r
959CONST CHAR16*\r
960EFIAPI\r
961GetStringNameFromHandle(\r
962 IN CONST EFI_HANDLE TheHandle,\r
963 IN CONST CHAR8 *Language\r
964 )\r
965{\r
966 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;\r
967 EFI_STATUS Status;\r
968 CHAR16 *RetVal;\r
969 CHAR8 *BestLang;\r
970\r
971 BestLang = NULL;\r
972\r
973 Status = gBS->OpenProtocol(\r
974 TheHandle,\r
975 &gEfiComponentName2ProtocolGuid,\r
976 (VOID**)&CompNameStruct,\r
977 gImageHandle,\r
978 NULL,\r
979 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
980 if (!EFI_ERROR(Status)) {\r
981 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
982 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
983 if (BestLang != NULL) {\r
984 FreePool (BestLang);\r
985 BestLang = NULL;\r
986 }\r
987 if (!EFI_ERROR(Status)) {\r
988 return (RetVal);\r
989 }\r
990 }\r
991 Status = gBS->OpenProtocol(\r
992 TheHandle,\r
993 &gEfiComponentNameProtocolGuid,\r
994 (VOID**)&CompNameStruct,\r
995 gImageHandle,\r
996 NULL,\r
997 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
998 if (!EFI_ERROR(Status)) {\r
999 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
1000 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
1001 if (BestLang != NULL) {\r
1002 FreePool (BestLang);\r
1003 }\r
1004 if (!EFI_ERROR(Status)) {\r
1005 return (RetVal);\r
1006 }\r
1007 }\r
1008 return (NULL);\r
1009}\r
1010\r
1011/**\r
1012 Function to initialize the file global mHandleList object for use in\r
1013 vonverting handles to index and index to handle.\r
1014\r
1015 @retval EFI_SUCCESS The operation was successful.\r
1016**/\r
1017EFI_STATUS\r
1018EFIAPI\r
1019InternalShellInitHandleList(\r
1020 VOID\r
1021 )\r
1022{\r
1023 EFI_STATUS Status;\r
1024 EFI_HANDLE *HandleBuffer;\r
1025 UINTN HandleCount;\r
1026 HANDLE_LIST *ListWalker;\r
1027\r
1028 if (mHandleList.NextIndex != 0) {\r
1029 return EFI_SUCCESS;\r
1030 }\r
1031 InitializeListHead(&mHandleList.List.Link);\r
1032 mHandleList.NextIndex = 1;\r
1033 Status = gBS->LocateHandleBuffer (\r
1034 AllHandles,\r
1035 NULL,\r
1036 NULL,\r
1037 &HandleCount,\r
1038 &HandleBuffer\r
1039 );\r
1040 ASSERT_EFI_ERROR(Status);\r
1041 if (EFI_ERROR(Status)) {\r
1042 return (Status);\r
1043 }\r
1044 for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
1045 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
1046 ASSERT(ListWalker != NULL);\r
1047 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex-1];\r
1048 ListWalker->TheIndex = mHandleList.NextIndex;\r
1049 InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
1050 }\r
1051 FreePool(HandleBuffer);\r
1052 return (EFI_SUCCESS);\r
1053}\r
1054\r
1055/**\r
1056 Function to retrieve the human-friendly index of a given handle. If the handle\r
1057 does not have a index one will be automatically assigned. The index value is valid\r
1058 until the termination of the shell application.\r
1059\r
1060 @param[in] TheHandle The handle to retrieve an index for.\r
1061\r
1062 @retval 0 A memory allocation failed.\r
1063 @return The index of the handle.\r
1064\r
1065**/\r
1066UINTN\r
1067EFIAPI\r
1068ConvertHandleToHandleIndex(\r
1069 IN CONST EFI_HANDLE TheHandle\r
1070 )\r
1071{\r
1072 EFI_STATUS Status;\r
1073 EFI_GUID **ProtocolBuffer;\r
1074 UINTN ProtocolCount;\r
1075 HANDLE_LIST *ListWalker;\r
1076\r
1077 if (TheHandle == NULL) {\r
1078 return 0;\r
1079 }\r
1080\r
1081 InternalShellInitHandleList();\r
1082\r
1083 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
1084 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
1085 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
1086 ){\r
1087 if (ListWalker->TheHandle == TheHandle) {\r
1088 //\r
1089 // Verify that TheHandle is still present in the Handle Database\r
1090 //\r
1091 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
1092 if (EFI_ERROR (Status)) {\r
1093 //\r
1094 // TheHandle is not present in the Handle Database, so delete from the handle list\r
1095 //\r
1096 RemoveEntryList (&ListWalker->Link);\r
1097 return 0;\r
1098 }\r
1099 FreePool (ProtocolBuffer);\r
1100 return (ListWalker->TheIndex);\r
1101 }\r
1102 }\r
1103\r
1104 //\r
1105 // Verify that TheHandle is valid handle\r
1106 //\r
1107 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
1108 if (EFI_ERROR (Status)) {\r
1109 //\r
1110 // TheHandle is not valid, so do not add to handle list\r
1111 //\r
1112 return 0;\r
1113 }\r
1114 FreePool (ProtocolBuffer);\r
1115\r
1116 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
1117 ASSERT(ListWalker != NULL);\r
1118 ListWalker->TheHandle = TheHandle;\r
1119 ListWalker->TheIndex = mHandleList.NextIndex++;\r
1120 InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
1121 return (ListWalker->TheIndex);\r
1122}\r
1123\r
1124\r
1125\r
1126/**\r
1127 Function to retrieve the EFI_HANDLE from the human-friendly index.\r
1128\r
1129 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.\r
1130\r
1131 @retval NULL The index was invalid.\r
1132 @return The EFI_HANDLE that index represents.\r
1133\r
1134**/\r
1135EFI_HANDLE\r
1136EFIAPI\r
1137ConvertHandleIndexToHandle(\r
1138 IN CONST UINTN TheIndex\r
1139 )\r
1140{\r
1141 EFI_STATUS Status;\r
1142 EFI_GUID **ProtocolBuffer;\r
1143 UINTN ProtocolCount;\r
1144 HANDLE_LIST *ListWalker;\r
1145\r
1146 InternalShellInitHandleList();\r
1147\r
1148 if (TheIndex >= mHandleList.NextIndex) {\r
1149 return NULL;\r
1150 }\r
1151\r
1152 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
1153 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
1154 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
1155 ){\r
1156 if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {\r
1157 //\r
1158 // Verify that LinkWalker->TheHandle is valid handle\r
1159 //\r
1160 Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
1161 if (EFI_ERROR (Status)) {\r
1162 //\r
1163 // TheHandle is not valid, so do not add to handle list\r
1164 //\r
1165 ListWalker->TheHandle = NULL;\r
1166 }\r
1167 return (ListWalker->TheHandle);\r
1168 }\r
1169 }\r
1170 return NULL;\r
1171}\r
1172\r
1173/**\r
1174 Gets all the related EFI_HANDLEs based on the mask supplied.\r
1175\r
1176 This function scans all EFI_HANDLES in the UEFI environment's handle database\r
1177 and returns the ones with the specified relationship (Mask) to the specified\r
1178 controller handle.\r
1179\r
1180 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
1181 If MatchingHandleCount is NULL, then ASSERT.\r
1182\r
1183 If MatchingHandleBuffer is not NULL upon a successful return the memory must be\r
1184 caller freed.\r
1185\r
1186 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.\r
1187 @param[in] ControllerHandle The handle with Device Path protocol on it.\r
1188 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in\r
1189 MatchingHandleBuffer.\r
1190 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount\r
1191 EFI_HANDLEs with a terminating NULL EFI_HANDLE.\r
1192 @param[out] HandleType An array of type information.\r
1193\r
1194 @retval EFI_SUCCESS The operation was successful, and any related handles\r
1195 are in MatchingHandleBuffer.\r
1196 @retval EFI_NOT_FOUND No matching handles were found.\r
1197 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
1198**/\r
1199EFI_STATUS\r
1200EFIAPI\r
1201ParseHandleDatabaseByRelationshipWithType (\r
1202 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
1203 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
1204 IN UINTN *HandleCount,\r
1205 OUT EFI_HANDLE **HandleBuffer,\r
1206 OUT UINTN **HandleType\r
1207 )\r
1208{\r
1209 EFI_STATUS Status;\r
1210 UINTN HandleIndex;\r
1211 EFI_GUID **ProtocolGuidArray;\r
1212 UINTN ArrayCount;\r
1213 UINTN ProtocolIndex;\r
1214 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;\r
1215 UINTN OpenInfoCount;\r
1216 UINTN OpenInfoIndex;\r
1217 UINTN ChildIndex;\r
1218 INTN DriverBindingHandleIndex;\r
1219\r
1220 ASSERT(HandleCount != NULL);\r
1221 ASSERT(HandleBuffer != NULL);\r
1222 ASSERT(HandleType != NULL);\r
1223 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
1224\r
1225 *HandleCount = 0;\r
1226 *HandleBuffer = NULL;\r
1227 *HandleType = NULL;\r
1228\r
1229 //\r
1230 // Retrieve the list of all handles from the handle database\r
1231 //\r
1232 Status = gBS->LocateHandleBuffer (\r
1233 AllHandles,\r
1234 NULL,\r
1235 NULL,\r
1236 HandleCount,\r
1237 HandleBuffer\r
1238 );\r
1239 if (EFI_ERROR (Status)) {\r
1240 return (Status);\r
1241 }\r
1242\r
1243 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
1244 ASSERT(*HandleType != NULL);\r
1245\r
1246 DriverBindingHandleIndex = -1;\r
1247 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
1248 if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {\r
1249 DriverBindingHandleIndex = (INTN)HandleIndex;\r
1250 }\r
1251 }\r
1252\r
1253 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
1254 //\r
1255 // Retrieve the list of all the protocols on each handle\r
1256 //\r
1257 Status = gBS->ProtocolsPerHandle (\r
1258 (*HandleBuffer)[HandleIndex],\r
1259 &ProtocolGuidArray,\r
1260 &ArrayCount\r
1261 );\r
1262 if (EFI_ERROR (Status)) {\r
1263 continue;\r
1264 }\r
1265\r
1266 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
1267\r
1268 //\r
1269 // Set the bit describing what this handle has\r
1270 //\r
1271 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
1272 (*HandleType)[HandleIndex] |= HR_IMAGE_HANDLE;\r
1273 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
1274 (*HandleType)[HandleIndex] |= HR_DRIVER_BINDING_HANDLE;\r
1275 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
1276 (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;\r
1277 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
1278 (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;\r
1279 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
1280 (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;\r
1281 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
1282 (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;\r
1283 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
1284 (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;\r
1285 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
1286 (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;\r
1287 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
1288 (*HandleType)[HandleIndex] |= HR_DEVICE_HANDLE;\r
1289 } else {\r
1290 DEBUG_CODE_BEGIN();\r
1291 ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);\r
1292 DEBUG_CODE_END();\r
1293 }\r
1294 //\r
1295 // Retrieve the list of agents that have opened each protocol\r
1296 //\r
1297 Status = gBS->OpenProtocolInformation (\r
1298 (*HandleBuffer)[HandleIndex],\r
1299 ProtocolGuidArray[ProtocolIndex],\r
1300 &OpenInfo,\r
1301 &OpenInfoCount\r
1302 );\r
1303 if (EFI_ERROR (Status)) {\r
1304 continue;\r
1305 }\r
1306\r
1307 if (ControllerHandle == NULL) {\r
1308 //\r
1309 // ControllerHandle == NULL and DriverBindingHandle != NULL. \r
1310 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing\r
1311 //\r
1312 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
1313 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
1314 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
1315 if (DriverBindingHandleIndex != -1) {\r
1316 (*HandleType)[DriverBindingHandleIndex] |= HR_DEVICE_DRIVER;\r
1317 }\r
1318 }\r
1319 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
1320 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
1321 if (DriverBindingHandleIndex != -1) {\r
1322 (*HandleType)[DriverBindingHandleIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
1323 }\r
1324 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
1325 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
1326 (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
1327 }\r
1328 }\r
1329 }\r
1330 }\r
1331 }\r
1332 if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
1333 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
1334 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
1335 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
1336 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
1337 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
1338 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
1339 (*HandleType)[ChildIndex] |= HR_DEVICE_DRIVER;\r
1340 }\r
1341 }\r
1342 }\r
1343 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
1344 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
1345 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
1346 (*HandleType)[ChildIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
1347 }\r
1348 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
1349 (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
1350 }\r
1351 }\r
1352 }\r
1353 }\r
1354 } else {\r
1355 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
1356 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
1357 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
1358 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
1359 }\r
1360 }\r
1361 }\r
1362 }\r
1363 }\r
1364 if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
1365 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
1366 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
1367 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
1368 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
1369 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
1370 if (DriverBindingHandleIndex != -1) {\r
1371 (*HandleType)[DriverBindingHandleIndex] |= HR_DEVICE_DRIVER;\r
1372 }\r
1373 }\r
1374 }\r
1375 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
1376 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
1377 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
1378 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
1379 (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
1380 }\r
1381 }\r
1382 }\r
1383\r
1384 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
1385 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
1386 (*HandleType)[ChildIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
1387 }\r
1388 }\r
1389 }\r
1390 }\r
1391 } else {\r
1392 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
1393 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
1394 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
1395 (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
1396 }\r
1397 }\r
1398 }\r
1399 }\r
1400 }\r
1401 FreePool (OpenInfo);\r
1402 }\r
1403 FreePool (ProtocolGuidArray);\r
1404 }\r
1405 return EFI_SUCCESS;\r
1406}\r
1407\r
1408/**\r
1409 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask\r
1410 supplied.\r
1411\r
1412 This function will scan all EFI_HANDLES in the UEFI environment's handle database\r
1413 and return all the ones with the specified relationship (Mask) to the specified\r
1414 controller handle.\r
1415\r
1416 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
1417 If MatchingHandleCount is NULL, then ASSERT.\r
1418\r
1419 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be\r
1420 caller freed.\r
1421\r
1422 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol\r
1423 on it.\r
1424 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.\r
1425 @param[in] Mask Mask of what relationship(s) is desired.\r
1426 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in\r
1427 MatchingHandleBuffer.\r
1428 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount\r
1429 EFI_HANDLEs and a terminating NULL EFI_HANDLE.\r
1430\r
1431 @retval EFI_SUCCESS The operation was sucessful and any related handles\r
1432 are in MatchingHandleBuffer;\r
1433 @retval EFI_NOT_FOUND No matching handles were found.\r
1434 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
1435**/\r
1436EFI_STATUS\r
1437EFIAPI\r
1438ParseHandleDatabaseByRelationship (\r
1439 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
1440 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
1441 IN CONST UINTN Mask,\r
1442 IN UINTN *MatchingHandleCount,\r
1443 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
1444 )\r
1445{\r
1446 EFI_STATUS Status;\r
1447 UINTN HandleCount;\r
1448 EFI_HANDLE *HandleBuffer;\r
1449 UINTN *HandleType;\r
1450 UINTN HandleIndex;\r
1451\r
1452 ASSERT(MatchingHandleCount != NULL);\r
1453 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
1454\r
1455 if ((Mask & HR_VALID_MASK) != Mask) {\r
1456 return (EFI_INVALID_PARAMETER);\r
1457 }\r
1458\r
1459 if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {\r
1460 return (EFI_INVALID_PARAMETER);\r
1461 }\r
1462\r
1463 *MatchingHandleCount = 0;\r
1464 if (MatchingHandleBuffer != NULL) {\r
1465 *MatchingHandleBuffer = NULL;\r
1466 }\r
1467\r
1468 HandleBuffer = NULL;\r
1469 HandleType = NULL;\r
1470\r
1471 Status = ParseHandleDatabaseByRelationshipWithType (\r
1472 DriverBindingHandle,\r
1473 ControllerHandle,\r
1474 &HandleCount,\r
1475 &HandleBuffer,\r
1476 &HandleType\r
1477 );\r
1478 if (!EFI_ERROR (Status)) {\r
1479 //\r
1480 // Count the number of handles that match the attributes in Mask\r
1481 //\r
1482 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {\r
1483 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
1484 (*MatchingHandleCount)++;\r
1485 }\r
1486 }\r
1487 //\r
1488 // If no handles match the attributes in Mask then return EFI_NOT_FOUND\r
1489 //\r
1490 if (*MatchingHandleCount == 0) {\r
1491 Status = EFI_NOT_FOUND;\r
1492 } else {\r
1493\r
1494 if (MatchingHandleBuffer == NULL) {\r
1495 //\r
1496 // Someone just wanted the count...\r
1497 //\r
1498 Status = EFI_SUCCESS;\r
1499 } else {\r
1500 //\r
1501 // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
1502 //\r
1503 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
1504 ASSERT(*MatchingHandleBuffer != NULL);\r
1505\r
1506 for (HandleIndex = 0,*MatchingHandleCount = 0\r
1507 ; HandleIndex < HandleCount\r
1508 ; HandleIndex++\r
1509 ){\r
1510 //\r
1511 // Fill the allocated buffer with the handles that matched the attributes in Mask\r
1512 //\r
1513 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
1514 (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
1515 }\r
1516 }\r
1517\r
1518 //\r
1519 // Make the last one NULL\r
1520 //\r
1521 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
1522\r
1523 Status = EFI_SUCCESS;\r
1524 } // MacthingHandleBuffer == NULL (ELSE)\r
1525 } // *MatchingHandleCount == 0 (ELSE)\r
1526 } // no error on ParseHandleDatabaseByRelationshipWithType\r
1527\r
1528 if (HandleBuffer != NULL) {\r
1529 FreePool (HandleBuffer);\r
1530 }\r
1531\r
1532 if (HandleType != NULL) {\r
1533 FreePool (HandleType);\r
1534 }\r
1535\r
1536 return Status;\r
1537}\r
1538\r
1539/**\r
1540 Gets handles for any child controllers of the passed in controller.\r
1541\r
1542 @param[in] ControllerHandle The handle of the "parent controller"\r
1543 @param[in] MatchingHandleCount Pointer to the number of handles in\r
1544 MatchingHandleBuffer on return.\r
1545 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
1546 return.\r
1547\r
1548\r
1549 @retval EFI_SUCCESS The operation was sucessful.\r
1550**/\r
1551EFI_STATUS\r
1552EFIAPI\r
1553ParseHandleDatabaseForChildControllers(\r
1554 IN CONST EFI_HANDLE ControllerHandle,\r
1555 IN UINTN *MatchingHandleCount,\r
1556 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
1557 )\r
1558{\r
1559 EFI_STATUS Status;\r
1560 UINTN HandleIndex;\r
1561 UINTN DriverBindingHandleCount;\r
1562 EFI_HANDLE *DriverBindingHandleBuffer;\r
1563 UINTN DriverBindingHandleIndex;\r
1564 UINTN ChildControllerHandleCount;\r
1565 EFI_HANDLE *ChildControllerHandleBuffer;\r
1566 UINTN ChildControllerHandleIndex;\r
1567 EFI_HANDLE *HandleBufferForReturn;\r
1568\r
1569 if (MatchingHandleCount == NULL) {\r
1570 return (EFI_INVALID_PARAMETER);\r
1571 }\r
1572 *MatchingHandleCount = 0;\r
1573\r
1574 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
1575 ControllerHandle,\r
1576 &DriverBindingHandleCount,\r
1577 &DriverBindingHandleBuffer\r
1578 );\r
1579 if (EFI_ERROR (Status)) {\r
1580 return Status;\r
1581 }\r
1582\r
1583 //\r
1584 // Get a buffer big enough for all the controllers.\r
1585 //\r
1586 HandleBufferForReturn = GetHandleListByProtocol(NULL);\r
1587 if (HandleBufferForReturn == NULL) {\r
1588 FreePool (DriverBindingHandleBuffer);\r
1589 return (EFI_NOT_FOUND);\r
1590 }\r
1591\r
1592 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {\r
1593 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
1594 DriverBindingHandleBuffer[DriverBindingHandleIndex],\r
1595 ControllerHandle,\r
1596 &ChildControllerHandleCount,\r
1597 &ChildControllerHandleBuffer\r
1598 );\r
1599 if (EFI_ERROR (Status)) {\r
1600 continue;\r
1601 }\r
1602\r
1603 for (ChildControllerHandleIndex = 0;\r
1604 ChildControllerHandleIndex < ChildControllerHandleCount;\r
1605 ChildControllerHandleIndex++\r
1606 ) {\r
1607 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {\r
1608 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {\r
1609 break;\r
1610 }\r
1611 }\r
1612 if (HandleIndex >= *MatchingHandleCount) {\r
1613 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];\r
1614 }\r
1615 }\r
1616\r
1617 FreePool (ChildControllerHandleBuffer);\r
1618 }\r
1619\r
1620 FreePool (DriverBindingHandleBuffer);\r
1621\r
1622 if (MatchingHandleBuffer != NULL) {\r
1623 *MatchingHandleBuffer = HandleBufferForReturn;\r
1624 } else {\r
1625 FreePool(HandleBufferForReturn);\r
1626 }\r
1627\r
1628 return (EFI_SUCCESS);\r
1629}\r
1630\r
1631/**\r
1632 Appends 1 buffer to another buffer. This will re-allocate the destination buffer\r
1633 if necessary to fit all of the data.\r
1634\r
1635 If DestinationBuffer is NULL, then ASSERT().\r
1636\r
1637 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.\r
1638 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.\r
1639 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.\r
1640 @param[in] SourceSize The number of bytes of SourceBuffer to append.\r
1641\r
1642 @retval NULL A memory allocation failed.\r
1643 @retval NULL A parameter was invalid.\r
1644 @return A pointer to (*DestinationBuffer).\r
1645**/\r
1646VOID*\r
1647EFIAPI\r
1648BuffernCatGrow (\r
1649 IN OUT VOID **DestinationBuffer,\r
1650 IN OUT UINTN *DestinationSize,\r
1651 IN VOID *SourceBuffer,\r
1652 IN UINTN SourceSize\r
1653 )\r
1654{\r
1655 UINTN LocalDestinationSize;\r
1656 UINTN LocalDestinationFinalSize;\r
1657\r
1658 ASSERT(DestinationBuffer != NULL);\r
1659\r
1660 if (SourceSize == 0 || SourceBuffer == NULL) {\r
1661 return (*DestinationBuffer);\r
1662 }\r
1663\r
1664 if (DestinationSize == NULL) {\r
1665 LocalDestinationSize = 0;\r
1666 } else {\r
1667 LocalDestinationSize = *DestinationSize;\r
1668 }\r
1669\r
1670 LocalDestinationFinalSize = LocalDestinationSize + SourceSize;\r
1671\r
1672 if (DestinationSize != NULL) {\r
1673 *DestinationSize = LocalDestinationSize;\r
1674 }\r
1675\r
1676 if (LocalDestinationSize == 0) {\r
1677 // allcoate\r
1678 *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);\r
1679 } else {\r
1680 // reallocate\r
1681 *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);\r
1682 }\r
1683\r
1684 ASSERT(*DestinationBuffer != NULL);\r
1685\r
1686 // copy\r
1687 return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));\r
1688}\r
1689\r
1690/**\r
1691 Gets handles for any child devices produced by the passed in driver.\r
1692\r
1693 @param[in] DriverHandle The handle of the driver.\r
1694 @param[in] MatchingHandleCount Pointer to the number of handles in\r
1695 MatchingHandleBuffer on return.\r
1696 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
1697 return.\r
1698 @retval EFI_SUCCESS The operation was sucessful.\r
1699 @sa ParseHandleDatabaseByRelationship\r
1700**/\r
1701EFI_STATUS\r
1702EFIAPI\r
1703ParseHandleDatabaseForChildDevices(\r
1704 IN CONST EFI_HANDLE DriverHandle,\r
1705 IN UINTN *MatchingHandleCount,\r
1706 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
1707 )\r
1708{\r
1709 EFI_HANDLE *Buffer;\r
1710 EFI_HANDLE *Buffer2;\r
1711 UINTN Count1;\r
1712 UINTN Count2;\r
1713 UINTN HandleIndex;\r
1714 EFI_STATUS Status;\r
1715 UINTN HandleBufferSize;\r
1716\r
1717 ASSERT(MatchingHandleCount != NULL);\r
1718\r
1719 HandleBufferSize = 0;\r
1720 Buffer = NULL;\r
1721 Buffer2 = NULL;\r
1722 *MatchingHandleCount = 0;\r
1723\r
1724 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
1725 DriverHandle,\r
1726 &Count1,\r
1727 &Buffer\r
1728 );\r
1729 if (!EFI_ERROR (Status)) {\r
1730 for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {\r
1731 //\r
1732 // now find the children\r
1733 //\r
1734 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
1735 DriverHandle,\r
1736 Buffer[HandleIndex],\r
1737 &Count2,\r
1738 &Buffer2\r
1739 );\r
1740 if (EFI_ERROR(Status)) {\r
1741 break;\r
1742 }\r
1743 //\r
1744 // save out required and optional data elements\r
1745 //\r
1746 *MatchingHandleCount += Count2;\r
1747 if (MatchingHandleBuffer != NULL) {\r
1748 *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));\r
1749 }\r
1750\r
1751 //\r
1752 // free the memory\r
1753 //\r
1754 if (Buffer2 != NULL) {\r
1755 FreePool(Buffer2);\r
1756 }\r
1757 }\r
1758 }\r
1759\r
1760 if (Buffer != NULL) {\r
1761 FreePool(Buffer);\r
1762 }\r
1763 return (Status);\r
1764}\r
1765\r
1766/**\r
1767 Function to get all handles that support a given protocol or all handles.\r
1768\r
1769 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL\r
1770 then the function will return all handles.\r
1771\r
1772 @retval NULL A memory allocation failed.\r
1773 @return A NULL terminated list of handles.\r
1774**/\r
1775EFI_HANDLE*\r
1776EFIAPI\r
1777GetHandleListByProtocol (\r
1778 IN CONST EFI_GUID *ProtocolGuid OPTIONAL\r
1779 )\r
1780{\r
1781 EFI_HANDLE *HandleList;\r
1782 UINTN Size;\r
1783 EFI_STATUS Status;\r
1784\r
1785 Size = 0;\r
1786 HandleList = NULL;\r
1787\r
1788 //\r
1789 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!\r
1790 //\r
1791 if (ProtocolGuid == NULL) {\r
1792 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
1793 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1794 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
1795 if (HandleList == NULL) {\r
1796 return (NULL);\r
1797 }\r
1798 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
1799 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
1800 }\r
1801 } else {\r
1802 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
1803 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1804 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
1805 if (HandleList == NULL) {\r
1806 return (NULL);\r
1807 }\r
1808 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
1809 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
1810 }\r
1811 }\r
1812 if (EFI_ERROR(Status)) {\r
1813 if (HandleList != NULL) {\r
1814 FreePool(HandleList);\r
1815 }\r
1816 return (NULL);\r
1817 }\r
1818 return (HandleList);\r
1819}\r
1820\r
1821/**\r
1822 Function to get all handles that support some protocols.\r
1823\r
1824 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.\r
1825\r
1826 @retval NULL A memory allocation failed.\r
1827 @retval NULL ProtocolGuids was NULL.\r
1828 @return A NULL terminated list of EFI_HANDLEs.\r
1829**/\r
1830EFI_HANDLE*\r
1831EFIAPI\r
1832GetHandleListByProtocolList (\r
1833 IN CONST EFI_GUID **ProtocolGuids\r
1834 )\r
1835{\r
1836 EFI_HANDLE *HandleList;\r
1837 UINTN Size;\r
1838 UINTN TotalSize;\r
1839 UINTN TempSize;\r
1840 EFI_STATUS Status;\r
1841 CONST EFI_GUID **GuidWalker;\r
1842 EFI_HANDLE *HandleWalker1;\r
1843 EFI_HANDLE *HandleWalker2;\r
1844\r
1845 Size = 0;\r
1846 HandleList = NULL;\r
1847 TotalSize = sizeof(EFI_HANDLE);\r
1848\r
1849 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){\r
1850 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);\r
1851 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1852 TotalSize += Size;\r
1853 }\r
1854 }\r
1855\r
1856 //\r
1857 // No handles were found... \r
1858 //\r
1859 if (TotalSize == sizeof(EFI_HANDLE)) {\r
1860 return (NULL);\r
1861 }\r
1862\r
1863 HandleList = AllocateZeroPool(TotalSize);\r
1864 if (HandleList == NULL) {\r
1865 return (NULL);\r
1866 }\r
1867\r
1868 Size = 0;\r
1869 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){\r
1870 TempSize = TotalSize - Size;\r
1871 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));\r
1872\r
1873 //\r
1874 // Allow for missing protocols... Only update the 'used' size upon success.\r
1875 //\r
1876 if (!EFI_ERROR(Status)) {\r
1877 Size += TempSize;\r
1878 }\r
1879 }\r
1880 ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);\r
1881\r
1882 for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {\r
1883 for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {\r
1884 if (*HandleWalker1 == *HandleWalker2) {\r
1885 //\r
1886 // copy memory back 1 handle width.\r
1887 //\r
1888 CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));\r
1889 }\r
1890 }\r
1891 }\r
1892\r
1893 return (HandleList);\r
1894}\r
1895\r
1896\r
1897\r
1898\r
1899\r
1900\r
1901\r
1902\r
1903\r
1904\r
EFI Development Kit II mirror for PVE