/** @file\r
Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
\r
- Copyright (c) 2013 Hewlett-Packard Development Company, L.P.\r
- Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+ Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>\r
+ (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r
+ (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>\r
+ SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "UefiHandleParsingLib.h"\r
#include "IndustryStandard/Acpi10.h"\r
+#include "IndustryStandard/Pci.h"\r
+#include <PiDxe.h>\r
+#include <Protocol/FirmwareVolume2.h>\r
\r
-EFI_HANDLE mHandleParsingHiiHandle;\r
+EFI_HANDLE mHandleParsingHiiHandle = NULL;\r
HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};\r
+GUID_INFO_BLOCK *mGuidList;\r
+UINTN mGuidListCount;\r
+\r
+/**\r
+ Function to find the file name associated with a LoadedImageProtocol.\r
+\r
+ @param[in] LoadedImage An instance of LoadedImageProtocol.\r
+\r
+ @retval A string representation of the file name associated\r
+ with LoadedImage, or NULL if no name can be found.\r
+**/\r
+CHAR16*\r
+FindLoadedImageFileName (\r
+ IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage\r
+ )\r
+{\r
+ EFI_GUID *NameGuid;\r
+ EFI_STATUS Status;\r
+ EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
+ VOID *Buffer;\r
+ UINTN BufferSize;\r
+ UINT32 AuthenticationStatus;\r
+\r
+ if ((LoadedImage == NULL) || (LoadedImage->FilePath == NULL)) {\r
+ return NULL;\r
+ }\r
+\r
+ NameGuid = EfiGetNameGuidFromFwVolDevicePathNode((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)LoadedImage->FilePath);\r
+\r
+ if (NameGuid == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.\r
+ //\r
+ Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**) &Fv);\r
+\r
+ //\r
+ // FirmwareVolume2Protocol is PI, and is not required to be available.\r
+ //\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Read the user interface section of the image.\r
+ //\r
+ Buffer = NULL;\r
+ Status = Fv->ReadSection(Fv, NameGuid, EFI_SECTION_USER_INTERFACE, 0, &Buffer, &BufferSize, &AuthenticationStatus);\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // ReadSection returns just the section data, without any section header. For\r
+ // a user interface section, the only data is the file name.\r
+ //\r
+ return Buffer;\r
+}\r
+\r
+/**\r
+ Function to translate the EFI_MEMORY_TYPE into a string.\r
+\r
+ @param[in] Memory The memory type.\r
+\r
+ @retval A string representation of the type allocated from BS Pool.\r
+**/\r
+CHAR16*\r
+ConvertMemoryType (\r
+ IN CONST EFI_MEMORY_TYPE Memory\r
+ )\r
+{\r
+ CHAR16 *RetVal;\r
+ RetVal = NULL;\r
+\r
+ switch (Memory) {\r
+ case EfiReservedMemoryType: StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0); break;\r
+ case EfiLoaderCode: StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0); break;\r
+ case EfiLoaderData: StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0); break;\r
+ case EfiBootServicesCode: StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0); break;\r
+ case EfiBootServicesData: StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0); break;\r
+ case EfiRuntimeServicesCode: StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0); break;\r
+ case EfiRuntimeServicesData: StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0); break;\r
+ case EfiConventionalMemory: StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0); break;\r
+ case EfiUnusableMemory: StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0); break;\r
+ case EfiACPIReclaimMemory: StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0); break;\r
+ case EfiACPIMemoryNVS: StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0); break;\r
+ case EfiMemoryMappedIO: StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0); break;\r
+ case EfiMemoryMappedIOPortSpace: StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0); break;\r
+ case EfiPalCode: StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0); break;\r
+ case EfiMaxMemoryType: StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0); break;\r
+ default: ASSERT(FALSE);\r
+ }\r
+ return (RetVal);\r
+}\r
+\r
+/**\r
+ Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.\r
+\r
+ @param[in] Fmt The format type.\r
+\r
+ @retval A string representation of the type allocated from BS Pool.\r
+**/\r
+CHAR16*\r
+ConvertPixelFormat (\r
+ IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt\r
+ )\r
+{\r
+ CHAR16 *RetVal;\r
+ RetVal = NULL;\r
+\r
+ switch (Fmt) {\r
+ case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0); break;\r
+ case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0); break;\r
+ case PixelBitMask: StrnCatGrow(&RetVal, NULL, L"PixelBitMask", 0); break;\r
+ case PixelBltOnly: StrnCatGrow(&RetVal, NULL, L"PixelBltOnly", 0); break;\r
+ case PixelFormatMax: StrnCatGrow(&RetVal, NULL, L"PixelFormatMax", 0); break;\r
+ default: ASSERT(FALSE);\r
+ }\r
+ return (RetVal);\r
+}\r
\r
/**\r
Constructor for the library.\r
IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
- mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);\r
- if (mHandleParsingHiiHandle == NULL) {\r
- return (EFI_DEVICE_ERROR);\r
- }\r
+ mGuidListCount = 0;\r
+ mGuidList = NULL;\r
\r
+ //\r
+ // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.\r
+ //\r
return (EFI_SUCCESS);\r
}\r
\r
+/**\r
+ Initialization function for HII packages.\r
+\r
+**/\r
+VOID\r
+HandleParsingHiiInit (VOID)\r
+{\r
+ if (mHandleParsingHiiHandle == NULL) {\r
+ mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);\r
+ ASSERT (mHandleParsingHiiHandle != NULL);\r
+ }\r
+}\r
+\r
/**\r
Destructor for the library. free any resources.\r
\r
IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
+ UINTN LoopCount;\r
+\r
+ for (LoopCount = 0; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++) {\r
+ SHELL_FREE_NON_NULL(mGuidList[LoopCount].GuidId);\r
+ }\r
+\r
+ SHELL_FREE_NON_NULL(mGuidList);\r
if (mHandleParsingHiiHandle != NULL) {\r
HiiRemovePackages(mHandleParsingHiiHandle);\r
}\r
return (EFI_SUCCESS);\r
}\r
\r
-/*\r
+/**\r
+ Function to dump information about LoadedImage.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has LoadedImage installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A poitner to a string containing the information.\r
+**/\r
CHAR16*\r
EFIAPI\r
LoadedImageProtocolDumpInformation(\r
IN CONST BOOLEAN Verbose\r
)\r
{\r
- EFI_LOADED_IMAGE_PROTOCOL *Image;\r
+ EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
EFI_STATUS Status;\r
- EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
- EFI_DEVICE_PATH_PROTOCOL *DevPathNode;\r
- VOID *Buffer;\r
- UINTN BufferSize;\r
- UINT32 AuthenticationStatus;\r
- EFI_GUID *NameGuid;\r
- EFI_FIRMWARE_VOLUME_PROTOCOL *FV;\r
- EFI_FIRMWARE_VOLUME2_PROTOCOL *FV2;\r
-\r
- FV = NULL;\r
- FV2 = NULL;\r
- Buffer = NULL;\r
- BufferSize = 0;\r
-\r
- Status = HandleProtocol (\r
- TheHandle,\r
- &gEfiLoadedImageProtocolGuid,\r
- &Image);\r
- ASSERT_EFI_ERROR(Status);\r
+ CHAR16 *RetVal;\r
+ CHAR16 *Temp;\r
+ CHAR16 *FileName;\r
+ CHAR8 *PdbFileName;\r
+ CHAR16 *FilePath;\r
+ CHAR16 *CodeType;\r
+ CHAR16 *DataType;\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ (VOID**)&LoadedImage,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ FileName = FindLoadedImageFileName(LoadedImage);\r
+ FilePath = ConvertDevicePathToText(LoadedImage->FilePath, TRUE, TRUE);\r
+ if (!Verbose) {\r
+ if (FileName == NULL) {\r
+ FileName = FilePath;\r
+ } else {\r
+ SHELL_FREE_NON_NULL(FilePath);\r
+ }\r
+ return FileName;\r
+ }\r
+\r
+ HandleParsingHiiInit();\r
+ RetVal = NULL;\r
+ if (FileName != NULL) {\r
+ Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_NAME), NULL);\r
+\r
+ if (Temp != NULL) {\r
+ RetVal = CatSPrint(NULL, Temp, FileName);\r
+ }\r
\r
- DevPath = UnpackDevicePath (Image->FilePath);\r
+ SHELL_FREE_NON_NULL(Temp);\r
+ SHELL_FREE_NON_NULL(FileName);\r
+ }\r
\r
- if (DevPath == NULL) {\r
+ Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);\r
+ if (Temp == NULL) {\r
return NULL;\r
}\r
+ PdbFileName = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase);\r
+ DataType = ConvertMemoryType(LoadedImage->ImageDataType);\r
+ CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);\r
+\r
+ RetVal = CatSPrint(\r
+ RetVal,\r
+ Temp,\r
+ LoadedImage->Revision,\r
+ LoadedImage->ParentHandle,\r
+ LoadedImage->SystemTable,\r
+ LoadedImage->DeviceHandle,\r
+ FilePath,\r
+ PdbFileName,\r
+ LoadedImage->LoadOptionsSize,\r
+ LoadedImage->LoadOptions,\r
+ LoadedImage->ImageBase,\r
+ LoadedImage->ImageSize,\r
+ CodeType,\r
+ DataType,\r
+ LoadedImage->Unload\r
+ );\r
\r
- DevPathNode = DevPath;\r
\r
- while (!IsDevicePathEnd (DevPathNode)) {\r
- //\r
- // Find the Fv File path\r
- //\r
- NameGuid = GetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevPathNode);\r
- if (NameGuid != NULL) {\r
- Status = BS->HandleProtocol (\r
- Image->DeviceHandle,\r
- &gEfiFirmwareVolumeProtocolGuid,\r
- &FV\r
+ SHELL_FREE_NON_NULL(Temp);\r
+ SHELL_FREE_NON_NULL(FilePath);\r
+ SHELL_FREE_NON_NULL(CodeType);\r
+ SHELL_FREE_NON_NULL(DataType);\r
+\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about GOP.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has LoadedImage installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+GraphicsOutputProtocolDumpInformation(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;\r
+ EFI_STATUS Status;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *Temp;\r
+ CHAR16 *Fmt;\r
+ CHAR16 *TempRetVal;\r
+ UINTN GopInfoSize;\r
+ UINT32 Mode;\r
+ EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *GopInfo;\r
+\r
+ if (!Verbose) {\r
+ return (CatSPrint(NULL, L"GraphicsOutput"));\r
+ }\r
+\r
+ HandleParsingHiiInit();\r
+\r
+ Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);\r
+ if (Temp == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiGraphicsOutputProtocolGuid,\r
+ (VOID**)&GraphicsOutput,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ SHELL_FREE_NON_NULL (Temp);\r
+ return NULL;\r
+ }\r
+\r
+ Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);\r
+\r
+ RetVal = CatSPrint(\r
+ NULL,\r
+ Temp,\r
+ GraphicsOutput->Mode->MaxMode,\r
+ GraphicsOutput->Mode->Mode,\r
+ GraphicsOutput->Mode->FrameBufferBase,\r
+ (UINT64)GraphicsOutput->Mode->FrameBufferSize,\r
+ (UINT64)GraphicsOutput->Mode->SizeOfInfo,\r
+ GraphicsOutput->Mode->Info->Version,\r
+ GraphicsOutput->Mode->Info->HorizontalResolution,\r
+ GraphicsOutput->Mode->Info->VerticalResolution,\r
+ Fmt,\r
+ GraphicsOutput->Mode->Info->PixelsPerScanLine,\r
+ GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.RedMask,\r
+ GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.GreenMask,\r
+ GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask\r
+ );\r
+\r
+ SHELL_FREE_NON_NULL (Temp);\r
+\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_MAIN), NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ goto EXIT;\r
+ }\r
+\r
+ TempRetVal = CatSPrint (RetVal, Temp);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ if (TempRetVal == NULL) {\r
+ goto EXIT;\r
+ }\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (Temp);\r
+\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY), NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ goto EXIT;\r
+ }\r
+\r
+\r
+ for (Mode = 0; Mode < GraphicsOutput->Mode->MaxMode; Mode++) {\r
+ Status = GraphicsOutput->QueryMode (\r
+ GraphicsOutput,\r
+ Mode,\r
+ &GopInfoSize,\r
+ &GopInfo\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ continue;\r
+ }\r
+\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ Temp,\r
+ Mode,\r
+ GopInfo->HorizontalResolution,\r
+ GopInfo->VerticalResolution\r
);\r
- if (!EFI_ERROR (Status)) {\r
- Status = FV->ReadSection (\r
- FV,\r
- NameGuid,\r
- EFI_SECTION_USER_INTERFACE,\r
- 0,\r
- &Buffer,\r
- &BufferSize,\r
- &AuthenticationStatus\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- break;\r
- }\r
\r
- Buffer = NULL;\r
- } else {\r
- Status = BS->HandleProtocol (\r
- Image->DeviceHandle,\r
- &gEfiFirmwareVolume2ProtocolGuid,\r
- &FV2\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- Status = FV2->ReadSection (\r
- FV2,\r
- NameGuid,\r
- EFI_SECTION_USER_INTERFACE,\r
- 0,\r
- &Buffer,\r
- &BufferSize,\r
- &AuthenticationStatus\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- break;\r
- }\r
+ SHELL_FREE_NON_NULL (GopInfo);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ }\r
\r
- Buffer = NULL;\r
- }\r
- }\r
+\r
+EXIT:\r
+ SHELL_FREE_NON_NULL(Temp);\r
+ SHELL_FREE_NON_NULL(Fmt);\r
+\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about EDID Discovered Protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has LoadedImage installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+EdidDiscoveredProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_EDID_DISCOVERED_PROTOCOL *EdidDiscovered;\r
+ EFI_STATUS Status;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *Temp;\r
+ CHAR16 *TempRetVal;\r
+\r
+ if (!Verbose) {\r
+ return (CatSPrint (NULL, L"EDIDDiscovered"));\r
+ }\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiEdidDiscoveredProtocolGuid,\r
+ (VOID**)&EdidDiscovered,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN), NULL);\r
+ if (Temp == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ RetVal = CatSPrint (NULL, Temp, EdidDiscovered->SizeOfEdid);\r
+ SHELL_FREE_NON_NULL (Temp);\r
+\r
+ if (EdidDiscovered->SizeOfEdid != 0) {\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_DATA), NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ return NULL;\r
}\r
- //\r
- // Next device path node\r
- //\r
- DevPathNode = NextDevicePathNode (DevPathNode);\r
+ TempRetVal = CatSPrint (RetVal, Temp);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+\r
+ TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidDiscovered->SizeOfEdid, EdidDiscovered->Edid);\r
+ RetVal = TempRetVal;\r
}\r
+ return RetVal;\r
+}\r
\r
- FreePool (DevPath);\r
- return Buffer;\r
+/**\r
+ Function to dump information about EDID Active Protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has LoadedImage installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+EdidActiveProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_EDID_ACTIVE_PROTOCOL *EdidActive;\r
+ EFI_STATUS Status;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *Temp;\r
+ CHAR16 *TempRetVal;\r
+\r
+ if (!Verbose) {\r
+ return (CatSPrint (NULL, L"EDIDActive"));\r
+ }\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiEdidActiveProtocolGuid,\r
+ (VOID**)&EdidActive,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_MAIN), NULL);\r
+ if (Temp == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ RetVal = CatSPrint (NULL, Temp, EdidActive->SizeOfEdid);\r
+ SHELL_FREE_NON_NULL (Temp);\r
+\r
+ if (EdidActive->SizeOfEdid != 0) {\r
+ Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_DATA), NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ return NULL;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, Temp);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+\r
+ TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidActive->SizeOfEdid, EdidActive->Edid);\r
+ RetVal = TempRetVal;\r
+ }\r
+ return RetVal;\r
}\r
-*/\r
\r
/**\r
Function to dump information about PciRootBridgeIo.\r
return (CatSPrint(NULL, L"PciRootBridgeIo"));\r
}\r
\r
+ HandleParsingHiiInit();\r
+\r
Status = gBS->HandleProtocol(\r
TheHandle,\r
&gEfiPciRootBridgeIoProtocolGuid,\r
}\r
\r
Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_PH), NULL);\r
- ASSERT (Temp != NULL);\r
- Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);\r
+ if (Temp == NULL) {\r
+ return NULL;\r
+ }\r
+ Temp2 = CatSPrint(NULL, Temp, PciRootBridgeIo->ParentHandle);\r
FreePool(Temp);\r
RetVal = Temp2;\r
Temp2 = NULL;\r
- \r
+\r
Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);\r
- ASSERT (Temp != NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL(RetVal);\r
+ return NULL;\r
+ }\r
Temp2 = CatSPrint(RetVal, Temp, PciRootBridgeIo->SegmentNumber);\r
FreePool(Temp);\r
FreePool(RetVal);\r
Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);\r
if (!EFI_ERROR(Status)) {\r
Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_ATT), NULL);\r
- ASSERT (Temp != NULL); \r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL(RetVal);\r
+ return NULL;\r
+ }\r
Temp2 = CatSPrint(RetVal, Temp, Attributes);\r
FreePool(Temp);\r
FreePool(RetVal);\r
RetVal = Temp2;\r
Temp2 = NULL;\r
- \r
+\r
Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);\r
- ASSERT (Temp != NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL(RetVal);\r
+ return NULL;\r
+ }\r
Temp2 = CatSPrint(RetVal, Temp, Supports);\r
FreePool(Temp);\r
FreePool(RetVal);\r
Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);\r
if (!EFI_ERROR(Status) && Configuration != NULL) {\r
Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_TITLE), NULL);\r
- ASSERT (Temp != NULL);\r
+ if (Temp == NULL) {\r
+ SHELL_FREE_NON_NULL(RetVal);\r
+ return NULL;\r
+ }\r
Temp2 = CatSPrint(RetVal, Temp, Supports);\r
FreePool(Temp);\r
FreePool(RetVal);\r
break;\r
}\r
if (Temp != NULL) {\r
- Temp2 = CatSPrint(RetVal, L"%s", Temp);\r
+ Temp2 = CatSPrint(RetVal, L"\r\n%s", Temp);\r
FreePool(Temp);\r
FreePool(RetVal);\r
RetVal = Temp2;\r
Temp2 = NULL;\r
}\r
\r
- Temp2 = CatSPrint(RetVal, \r
- L"%H%02x %016lx %016lx %02x%N\r\n",\r
+ Temp2 = CatSPrint(RetVal,\r
+ L"%%H%02x %016lx %016lx %02x%%N",\r
Configuration->SpecificFlag,\r
Configuration->AddrRangeMin,\r
Configuration->AddrRangeMax,\r
return (NULL);\r
}\r
\r
+ HandleParsingHiiInit();\r
+\r
RetVal = NULL;\r
Size = 0;\r
\r
- Status = gBS->HandleProtocol(\r
- TheHandle,\r
- &gEfiSimpleTextOutProtocolGuid,\r
- (VOID**)&Dev);\r
+ Status = gBS->HandleProtocol(\r
+ TheHandle,\r
+ &gEfiSimpleTextOutProtocolGuid,\r
+ (VOID**)&Dev);\r
+\r
+ ASSERT_EFI_ERROR(Status);\r
+ ASSERT (Dev != NULL && Dev->Mode != NULL);\r
+\r
+ Size = (Dev->Mode->MaxMode + 1) * 80;\r
+ RetVal = AllocateZeroPool(Size);\r
+\r
+ Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER), NULL);\r
+ if (Temp != NULL) {\r
+ UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);\r
+ FreePool(Temp);\r
+ }\r
+\r
+ //\r
+ // Dump TextOut Info\r
+ //\r
+ Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE), NULL);\r
+ for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {\r
+ Status = Dev->QueryMode (Dev, Index, &Col, &Row);\r
+ NewSize = Size - StrSize(RetVal);\r
+ UnicodeSPrint(\r
+ RetVal + StrLen(RetVal),\r
+ NewSize,\r
+ Temp == NULL?L"":Temp,\r
+ Index == Dev->Mode->Mode ? L'*' : L' ',\r
+ Index,\r
+ !EFI_ERROR(Status)?(INTN)Col:-1,\r
+ !EFI_ERROR(Status)?(INTN)Row:-1\r
+ );\r
+ }\r
+ FreePool(Temp);\r
+ return (RetVal);\r
+}\r
+\r
+STATIC CONST UINTN VersionStringSize = 60;\r
+\r
+/**\r
+ Function to dump information about EfiDriverSupportedEfiVersion protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+DriverEfiVersionProtocolDumpInformation(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;\r
+ EFI_STATUS Status;\r
+ CHAR16 *RetVal;\r
+\r
+ Status = gBS->HandleProtocol(\r
+ TheHandle,\r
+ &gEfiDriverSupportedEfiVersionProtocolGuid,\r
+ (VOID**)&DriverEfiVersion);\r
+\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ RetVal = AllocateZeroPool(VersionStringSize);\r
+ if (RetVal != NULL) {\r
+ UnicodeSPrint (RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
+ }\r
+ return (RetVal);\r
+}\r
+/**\r
+ Function to convert device path to string.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] DevPath Pointer to device path instance.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+ @param[in] Length Maximum allowed text length of the device path.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+ConvertDevicePathToShortText(\r
+ IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,\r
+ IN CONST BOOLEAN Verbose,\r
+ IN CONST UINTN Length\r
+ )\r
+{\r
+ CHAR16 *Temp;\r
+ CHAR16 *Temp2;\r
+ UINTN Size;\r
+\r
+ //\r
+ // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
+ //\r
+ Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);\r
+ if (!Verbose && Temp != NULL && StrLen(Temp) > Length) {\r
+ Temp2 = NULL;\r
+ Size = 0;\r
+ Temp2 = StrnCatGrow(&Temp2, &Size, L"..", 0);\r
+ Temp2 = StrnCatGrow(&Temp2, &Size, Temp+(StrLen(Temp) - (Length - 2)), 0);\r
+ FreePool(Temp);\r
+ Temp = Temp2;\r
+ }\r
+ return (Temp);\r
+}\r
+\r
+/**\r
+ Function to dump protocol information.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+ @param[in] Protocol The protocol is needed to dump.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+STATIC CHAR16*\r
+EFIAPI\r
+DevicePathProtocolDumpInformationEx (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose,\r
+ IN EFI_GUID *Protocol\r
+)\r
+{\r
+ EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
+ CHAR16 *DevPathStr;\r
+ CHAR16 *DevPathStrTemp;\r
+ UINTN Size;\r
+ EFI_STATUS Status;\r
+ DevPathStr = NULL;\r
+ DevPathStrTemp = NULL;\r
+ Status = gBS->OpenProtocol(TheHandle, Protocol, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+ if (!EFI_ERROR(Status)) {\r
+ DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);\r
+ if (Verbose) {\r
+ Size = StrSize(DevPathStr) + sizeof(CHAR16) * 2;\r
+ DevPathStrTemp = AllocateZeroPool (Size);\r
+ if (DevPathStrTemp != NULL) {\r
+ StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), L" ", 2);\r
+ StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), DevPathStr, StrLen (DevPathStr));\r
+ }\r
+ FreePool (DevPathStr);\r
+ DevPathStr = DevPathStrTemp;\r
+ }\r
+ gBS->CloseProtocol(TheHandle, Protocol, gImageHandle, NULL);\r
+ }\r
+ return DevPathStr;\r
+}\r
+\r
+/**\r
+ Function to dump information about DevicePath protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+DevicePathProtocolDumpInformation(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);\r
+}\r
+\r
+/**\r
+ Function to dump information about LoadedImageDevicePath protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+LoadedImageDevicePathProtocolDumpInformation(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);\r
+}\r
+\r
+/**\r
+ Function to dump information about BusSpecificDriverOverride protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+BusSpecificDriverOverrideProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ CHAR16 *GetString;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *TempRetVal;\r
+ EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;\r
+ EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
+ EFI_HANDLE ImageHandle;\r
+ UINTN Size;\r
+\r
+ if (!Verbose) {\r
+ return NULL;\r
+ }\r
+ Size = 0;\r
+ GetString = NULL;\r
+ RetVal = NULL;\r
+ TempRetVal = NULL;\r
+ ImageHandle = 0;\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiBusSpecificDriverOverrideProtocolGuid,\r
+ (VOID**)&BusSpecificDriverOverride,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+ HandleParsingHiiInit ();\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BSDO_DUMP_MAIN), NULL);\r
+ if (GetString == NULL) {\r
+ return NULL;\r
+ }\r
+ do {\r
+ Status = BusSpecificDriverOverride->GetDriver (\r
+ BusSpecificDriverOverride,\r
+ &ImageHandle\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ Status = gBS->HandleProtocol (\r
+ ImageHandle,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ (VOID **) &LoadedImage\r
+ );\r
+ if(!EFI_ERROR (Status)) {\r
+ TempRetVal = CatSPrint (\r
+ TempRetVal,\r
+ GetString,\r
+ ConvertHandleToHandleIndex (ImageHandle),\r
+ ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE)\r
+ );\r
+ StrnCatGrow (&RetVal, &Size, TempRetVal, 0);\r
+ SHELL_FREE_NON_NULL (TempRetVal);\r
+ }\r
+ }\r
+ } while (!EFI_ERROR (Status));\r
+\r
+ SHELL_FREE_NON_NULL (GetString);\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about BlockIo protocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+BlockIoProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
+ EFI_BLOCK_IO_MEDIA *BlockMedia;\r
+ CHAR16 *GetString;\r
+ CHAR16 *RetVal;\r
+\r
+ if (!Verbose) {\r
+ return NULL;\r
+ }\r
+ GetString = NULL;\r
+ RetVal = NULL;\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiBlockIoProtocolGuid,\r
+ (VOID**)&BlockIo,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+ BlockMedia = BlockIo->Media;\r
+ //\r
+ // Per spec:\r
+ // The function (ReadBlocks) must return EFI_NO_MEDIA or\r
+ // EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe\r
+ // for changes in media state.\r
+ //\r
+ BlockIo->ReadBlocks (\r
+ BlockIo,\r
+ BlockIo->Media->MediaId,\r
+ 0,\r
+ 0,\r
+ NULL\r
+ );\r
+\r
+ HandleParsingHiiInit ();\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_BLOCKIO_INFO), NULL);\r
+ if (GetString == NULL) {\r
+ return NULL;\r
+ }\r
+ RetVal = CatSPrint (\r
+ RetVal,\r
+ GetString,\r
+ BlockMedia->RemovableMedia ? L"Removable " : L"Fixed ",\r
+ BlockMedia->MediaPresent ? L"" : L"not-present ",\r
+ BlockMedia->MediaId,\r
+ BlockMedia->BlockSize,\r
+ BlockMedia->LastBlock,\r
+ MultU64x32 (BlockMedia->LastBlock + 1, BlockMedia->BlockSize),\r
+ BlockMedia->LogicalPartition ? L"partition" : L"raw",\r
+ BlockMedia->ReadOnly ? L"ro" : L"rw",\r
+ BlockMedia->WriteCaching ? L"cached" : L"!cached"\r
+ );\r
+\r
+ SHELL_FREE_NON_NULL (GetString);\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about DebugSupport Protocol.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+DebugSupportProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;\r
+ CHAR16 *GetString;\r
+ CHAR16 *RetVal;\r
+\r
+ if (!Verbose) {\r
+ return NULL;\r
+ }\r
+ GetString = NULL;\r
+ RetVal = NULL;\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiDebugSupportProtocolGuid,\r
+ (VOID**)&DebugSupport,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+ HandleParsingHiiInit ();\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_INFO), NULL);\r
+ if (GetString == NULL) {\r
+ return NULL;\r
+ }\r
+ //\r
+ // Dump Debug support info\r
+ //\r
+ switch (DebugSupport->Isa) {\r
+ case (IsaIa32):\r
+ RetVal = CatSPrint (RetVal, GetString, L"IA-32");\r
+ break;\r
+ case (IsaIpf):\r
+ RetVal = CatSPrint (RetVal, GetString, L"IPF");\r
+ break;\r
+ case (IsaEbc):\r
+ RetVal = CatSPrint (RetVal, GetString, L"EBC");\r
+ break;\r
+ default:\r
+ SHELL_FREE_NON_NULL (GetString);\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_DEBUGSUPPORT_UNKNOWN), NULL);\r
+ RetVal = GetString != NULL ? CatSPrint (RetVal, GetString, DebugSupport->Isa) : NULL;\r
+ break;\r
+ }\r
+\r
+ SHELL_FREE_NON_NULL (GetString);\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about PciIoProtocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has PciRootBridgeIo installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+PciIoProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_PCI_IO_PROTOCOL *PciIo;\r
+ PCI_TYPE00 Pci;\r
+ UINTN Segment;\r
+ UINTN Bus;\r
+ UINTN Device;\r
+ UINTN Function;\r
+ UINTN Index;\r
+ CHAR16 *GetString;\r
+ CHAR16 *TempRetVal;\r
+ CHAR16 *RetVal;\r
+\r
+ if (!Verbose) {\r
+ return (NULL);\r
+ }\r
+ RetVal = NULL;\r
+ GetString = NULL;\r
+ TempRetVal = NULL;\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiPciIoProtocolGuid,\r
+ (VOID**)&PciIo,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR(Status)) {\r
+ return NULL;\r
+ }\r
+ PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);\r
+ PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);\r
+ HandleParsingHiiInit ();\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIIO_DUMP_MAIN), NULL);\r
+ if (GetString == NULL) {\r
+ return NULL;\r
+ }\r
+ RetVal = CatSPrint (\r
+ NULL,\r
+ GetString,\r
+ Segment,\r
+ Bus,\r
+ Device,\r
+ Function,\r
+ PciIo->RomSize,\r
+ PciIo->RomImage,\r
+ Pci.Hdr.VendorId,\r
+ Pci.Hdr.DeviceId,\r
+ Pci.Hdr.ClassCode[0],\r
+ Pci.Hdr.ClassCode[1],\r
+ Pci.Hdr.ClassCode[2]\r
+ );\r
+ for (Index = 0; Index < sizeof (Pci); Index ++) {\r
+ if ((Index % 0x10) == 0) {\r
+ TempRetVal = CatSPrint (RetVal, L"\r\n %02x", *((UINT8 *) (&Pci) + Index));\r
+ } else {\r
+ TempRetVal = CatSPrint (RetVal, L"%02x", *((UINT8 *) (&Pci) + Index));\r
+ }\r
+ FreePool (RetVal);\r
+ RetVal = TempRetVal;\r
+ TempRetVal = NULL;\r
+ }\r
+\r
+ FreePool(GetString);\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about UsbIoProtocol.\r
+\r
+ This will allocate the return buffer from boot services pool.\r
+\r
+ @param[in] TheHandle The handle that has PciRootBridgeIo installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A poitner to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+UsbIoProtocolDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_USB_IO_PROTOCOL *UsbIo;\r
+ EFI_USB_INTERFACE_DESCRIPTOR InterfaceDesc;\r
+ CHAR16 *GetString;\r
+ CHAR16 *RetVal;\r
+\r
+ if (!Verbose) {\r
+ return (NULL);\r
+ }\r
+ RetVal = NULL;\r
+ GetString = NULL;\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiUsbIoProtocolGuid,\r
+ (VOID**)&UsbIo,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR(Status)) {\r
+ return NULL;\r
+ }\r
+ UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);\r
+ HandleParsingHiiInit ();\r
+ GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_USBIO_DUMP_MAIN), NULL);\r
+ if (GetString == NULL) {\r
+ return NULL;\r
+ }\r
+ RetVal = CatSPrint (\r
+ NULL,\r
+ GetString,\r
+ InterfaceDesc.InterfaceNumber,\r
+ InterfaceDesc.InterfaceClass,\r
+ InterfaceDesc.InterfaceSubClass,\r
+ InterfaceDesc.InterfaceProtocol\r
+ );\r
+\r
+ FreePool (GetString);\r
+ return RetVal;\r
+}\r
+\r
+/**\r
+ Function to dump information about EfiAdapterInformation Protocol.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+AdapterInformationDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_ADAPTER_INFORMATION_PROTOCOL *EfiAdptrInfoProtocol;\r
+ UINTN InfoTypesBufferCount;\r
+ UINTN GuidIndex;\r
+ EFI_GUID *InfoTypesBuffer;\r
+ CHAR16 *GuidStr;\r
+ CHAR16 *TempStr;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *TempRetVal;\r
+ VOID *InformationBlock;\r
+ UINTN InformationBlockSize;\r
+\r
+ if (!Verbose) {\r
+ return (CatSPrint(NULL, L"AdapterInfo"));\r
+ }\r
+\r
+ InfoTypesBuffer = NULL;\r
+ InformationBlock = NULL;\r
+\r
+\r
+ Status = gBS->OpenProtocol (\r
+ (EFI_HANDLE) (TheHandle),\r
+ &gEfiAdapterInformationProtocolGuid,\r
+ (VOID **) &EfiAdptrInfoProtocol,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Get a list of supported information types for this instance of the protocol.\r
+ //\r
+ Status = EfiAdptrInfoProtocol->GetSupportedTypes (\r
+ EfiAdptrInfoProtocol,\r
+ &InfoTypesBuffer,\r
+ &InfoTypesBufferCount\r
+ );\r
+ RetVal = NULL;\r
+ if (EFI_ERROR (Status)) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED), NULL);\r
+ if (TempStr != NULL) {\r
+ RetVal = CatSPrint (NULL, TempStr, Status);\r
+ } else {\r
+ goto ERROR_EXIT;\r
+ }\r
+ } else {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SUPP_TYPE_HEADER), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ RetVal = CatSPrint (NULL, TempStr);\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+\r
+ if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else {\r
+\r
+ GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
+ if (GuidStr == NULL) {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+ SHELL_FREE_NON_NULL(GuidStr);\r
+ //\r
+ // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP\r
+ //\r
+ continue;\r
+ } else {\r
+ TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL(GuidStr);\r
+ }\r
+ }\r
+\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ Status = EfiAdptrInfoProtocol->GetInformation (\r
+ EfiAdptrInfoProtocol,\r
+ &InfoTypesBuffer[GuidIndex],\r
+ &InformationBlock,\r
+ &InformationBlockSize\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else {\r
+ if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,\r
+ ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,\r
+ ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],\r
+ ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNDI_IPV6_INFO), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ } else {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ }\r
+ }\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+ SHELL_FREE_NON_NULL (InformationBlock);\r
+ }\r
+ }\r
+\r
+ SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
+ return RetVal;\r
+\r
+ERROR_EXIT:\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
+ SHELL_FREE_NON_NULL (InformationBlock);\r
+ return NULL;\r
+}\r
+\r
+/**\r
+ Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.\r
+\r
+ @param[in] TheHandle The handle that has the protocol installed.\r
+ @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
+\r
+ @retval A pointer to a string containing the information.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+FirmwareManagementDumpInformation (\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_FIRMWARE_MANAGEMENT_PROTOCOL *EfiFwMgmtProtocol;\r
+ EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo;\r
+ EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *ImageInfoV1;\r
+ EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *ImageInfoV2;\r
+ UINT64 AttributeSetting;\r
+ UINTN ImageInfoSize;\r
+ UINTN DescriptorSize;\r
+ UINT32 DescriptorVersion;\r
+ UINT32 PackageVersion;\r
+ UINT8 DescriptorCount;\r
+ UINT8 Index;\r
+ UINT8 Index1;\r
+ UINT8 ImageCount;\r
+ CHAR16 *PackageVersionName;\r
+ CHAR16 *TempStr;\r
+ CHAR16 *RetVal;\r
+ CHAR16 *TempRetVal;\r
+ CHAR16 *AttributeSettingStr;\r
+ BOOLEAN Found;\r
+ BOOLEAN AttributeSupported;\r
+\r
+ //\r
+ // Initialize local variables\r
+ //\r
+ ImageCount = 0;\r
+ ImageInfoSize = 1;\r
+ AttributeSetting = 0;\r
+ Found = FALSE;\r
+ AttributeSupported = FALSE;\r
+ ImageInfo = NULL;\r
+ ImageInfoV1 = NULL;\r
+ ImageInfoV2 = NULL;\r
+ PackageVersionName = NULL;\r
+ RetVal = NULL;\r
+ TempRetVal = NULL;\r
+ TempStr = NULL;\r
+ AttributeSettingStr = NULL;\r
+\r
+ if (!Verbose) {\r
+ return (CatSPrint(NULL, L"FirmwareManagement"));\r
+ }\r
+\r
+ Status = gBS->OpenProtocol (\r
+ (EFI_HANDLE) (TheHandle),\r
+ &gEfiFirmwareManagementProtocolGuid,\r
+ (VOID **) &EfiFwMgmtProtocol,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
+ }\r
+\r
+ Status = EfiFwMgmtProtocol->GetImageInfo (\r
+ EfiFwMgmtProtocol,\r
+ &ImageInfoSize,\r
+ ImageInfo,\r
+ &DescriptorVersion,\r
+ &DescriptorCount,\r
+ &DescriptorSize,\r
+ &PackageVersion,\r
+ &PackageVersionName\r
+ );\r
+\r
+ if (Status == EFI_BUFFER_TOO_SMALL) {\r
+ ImageInfo = AllocateZeroPool (ImageInfoSize);\r
+\r
+ if (ImageInfo == NULL) {\r
+ Status = EFI_OUT_OF_RESOURCES;\r
+ } else {\r
+ Status = EfiFwMgmtProtocol->GetImageInfo (\r
+ EfiFwMgmtProtocol,\r
+ &ImageInfoSize,\r
+ ImageInfo,\r
+ &DescriptorVersion,\r
+ &DescriptorCount,\r
+ &DescriptorSize,\r
+ &PackageVersion,\r
+ &PackageVersionName\r
+ );\r
+ }\r
+ }\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ goto ERROR_EXIT;\r
+ }\r
+\r
+ //\r
+ // Decode Image Descriptor data only if its version is supported\r
+ //\r
+ if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {\r
+\r
+ if (ImageInfo == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+\r
+ ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;\r
+ ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;\r
+\r
+ //\r
+ // Set ImageInfoSize in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ //\r
+ // Set DescriptorVersion in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ //\r
+ // Set DescriptorCount in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+\r
+ //\r
+ // Set DescriptorSize in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ //\r
+ // Set PackageVersion in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ //\r
+ // Set PackageVersionName in return buffer\r
+ //\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+\r
+ for (Index = 0; Index < DescriptorCount; Index++) {\r
+ //\r
+ // First check if Attribute is supported\r
+ // and generate a string for AttributeSetting field\r
+ //\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSupported = FALSE;\r
+ AttributeSetting = 0;\r
+ if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+ if (ImageInfoV1[Index].AttributesSupported != 0x0) {\r
+ AttributeSupported = TRUE;\r
+ AttributeSetting = ImageInfoV1[Index].AttributesSetting;\r
+ }\r
+ } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+ if (ImageInfoV2[Index].AttributesSupported != 0x0) {\r
+ AttributeSupported = TRUE;\r
+ AttributeSetting = ImageInfoV2[Index].AttributesSetting;\r
+ }\r
+ } else {\r
+ if (ImageInfo[Index].AttributesSupported != 0x0) {\r
+ AttributeSupported = TRUE;\r
+ AttributeSetting = ImageInfo[Index].AttributesSetting;\r
+ }\r
+ }\r
+\r
+ if (!AttributeSupported) {\r
+ AttributeSettingStr = CatSPrint (NULL, L"None");\r
+ } else {\r
+ AttributeSettingStr = CatSPrint (NULL, L"(");\r
+\r
+ if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+ if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+ if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+ if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+ if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+ TempRetVal = CatSPrint (AttributeSettingStr, L" )");\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
+ AttributeSettingStr = TempRetVal;\r
+ }\r
+\r
+ if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+ if (ImageInfoV1[Index].ImageIndex != 0x0) {\r
+ ImageCount++;\r
+ }\r
+\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ Index,\r
+ ImageInfoV1[Index].ImageIndex,\r
+ &ImageInfoV1[Index].ImageTypeId,\r
+ ImageInfoV1[Index].ImageId,\r
+ ImageInfoV1[Index].ImageIdName,\r
+ ImageInfoV1[Index].Version,\r
+ ImageInfoV1[Index].VersionName,\r
+ ImageInfoV1[Index].Size,\r
+ ImageInfoV1[Index].AttributesSupported,\r
+ AttributeSettingStr,\r
+ ImageInfoV1[Index].Compatibilities\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+ } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+ if (ImageInfoV2[Index].ImageIndex != 0x0) {\r
+ ImageCount++;\r
+ }\r
\r
- ASSERT_EFI_ERROR(Status);\r
- ASSERT (Dev != NULL && Dev->Mode != NULL);\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ Index,\r
+ ImageInfoV2[Index].ImageIndex,\r
+ &ImageInfoV2[Index].ImageTypeId,\r
+ ImageInfoV2[Index].ImageId,\r
+ ImageInfoV2[Index].ImageIdName,\r
+ ImageInfoV2[Index].Version,\r
+ ImageInfoV2[Index].VersionName,\r
+ ImageInfoV2[Index].Size,\r
+ ImageInfoV2[Index].AttributesSupported,\r
+ AttributeSettingStr,\r
+ ImageInfoV2[Index].Compatibilities,\r
+ ImageInfoV2[Index].LowestSupportedImageVersion\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+ } else {\r
+ if (ImageInfo[Index].ImageIndex != 0x0) {\r
+ ImageCount++;\r
+ }\r
\r
- Size = (Dev->Mode->MaxMode + 1) * 80;\r
- RetVal = AllocateZeroPool(Size);\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (\r
+ RetVal,\r
+ TempStr,\r
+ Index,\r
+ ImageInfo[Index].ImageIndex,\r
+ &ImageInfo[Index].ImageTypeId,\r
+ ImageInfo[Index].ImageId,\r
+ ImageInfo[Index].ImageIdName,\r
+ ImageInfo[Index].Version,\r
+ ImageInfo[Index].VersionName,\r
+ ImageInfo[Index].Size,\r
+ ImageInfo[Index].AttributesSupported,\r
+ AttributeSettingStr,\r
+ ImageInfo[Index].Compatibilities,\r
+ ImageInfo[Index].LowestSupportedImageVersion,\r
+ ImageInfo[Index].LastAttemptVersion,\r
+ ImageInfo[Index].LastAttemptStatus,\r
+ ImageInfo[Index].HardwareInstance\r
+ );\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
+ }\r
+ }\r
+ }\r
\r
- Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER), NULL);\r
- if (Temp != NULL) {\r
- UnicodeSPrint(RetVal, Size, Temp, Dev, Dev->Mode->Attribute);\r
- FreePool(Temp);\r
+ if (ImageCount > 0) {\r
+ for (Index=0; Index<DescriptorCount; Index++) {\r
+ for (Index1=Index+1; Index1<DescriptorCount; Index1++) {\r
+ if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
+ if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {\r
+ Found = TRUE;\r
+ //\r
+ // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+ //\r
+ goto ENDLOOP;\r
+ }\r
+ } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
+ if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {\r
+ Found = TRUE;\r
+ //\r
+ // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+ //\r
+ goto ENDLOOP;\r
+ }\r
+ } else {\r
+ if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {\r
+ Found = TRUE;\r
+ //\r
+ // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
+ //\r
+ goto ENDLOOP;\r
+ }\r
+ }\r
+ }\r
+ }\r
}\r
\r
+ENDLOOP:\r
//\r
- // Dump TextOut Info\r
+ // Check if ImageId with duplicate value was found\r
//\r
- Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE), NULL);\r
- for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {\r
- Status = Dev->QueryMode (Dev, Index, &Col, &Row);\r
- NewSize = Size - StrSize(RetVal);\r
- UnicodeSPrint(\r
- RetVal + StrLen(RetVal),\r
- NewSize,\r
- Temp == NULL?L"":Temp,\r
- Index == Dev->Mode->Mode ? L'*' : L' ',\r
- Index,\r
- !EFI_ERROR(Status)?(INTN)Col:-1,\r
- !EFI_ERROR(Status)?(INTN)Row:-1\r
- );\r
+ if (Found) {\r
+ TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE), NULL);\r
+ if (TempStr == NULL) {\r
+ goto ERROR_EXIT;\r
+ }\r
+ TempRetVal = CatSPrint (RetVal, TempStr);\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ RetVal = TempRetVal;\r
+ SHELL_FREE_NON_NULL (TempStr);\r
}\r
- FreePool(Temp);\r
- return (RetVal);\r
-}\r
-\r
-STATIC CONST UINTN VersionStringSize = 60;\r
\r
-/**\r
- Function to dump information about EfiDriverSupportedEfiVersion protocol.\r
-\r
- This will allocate the return buffer from boot services pool.\r
-\r
- @param[in] TheHandle The handle that has the protocol installed.\r
- @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
-\r
- @retval A poitner to a string containing the information.\r
-**/\r
-CHAR16*\r
-EFIAPI\r
-DriverEfiVersionProtocolDumpInformation(\r
- IN CONST EFI_HANDLE TheHandle,\r
- IN CONST BOOLEAN Verbose\r
- )\r
-{\r
- EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;\r
- EFI_STATUS Status;\r
- CHAR16 *RetVal;\r
+ SHELL_FREE_NON_NULL (ImageInfo);\r
+ SHELL_FREE_NON_NULL (PackageVersionName);\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
\r
- Status = gBS->HandleProtocol(\r
- TheHandle,\r
- &gEfiDriverSupportedEfiVersionProtocolGuid,\r
- (VOID**)&DriverEfiVersion);\r
+ return RetVal;\r
\r
- ASSERT_EFI_ERROR(Status);\r
+ERROR_EXIT:\r
+ SHELL_FREE_NON_NULL (RetVal);\r
+ SHELL_FREE_NON_NULL (ImageInfo);\r
+ SHELL_FREE_NON_NULL (PackageVersionName);\r
+ SHELL_FREE_NON_NULL (AttributeSettingStr);\r
\r
- RetVal = AllocateZeroPool(VersionStringSize);\r
- ASSERT(RetVal != NULL);\r
- UnicodeSPrint(RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
- return (RetVal);\r
+ return NULL;\r
}\r
\r
/**\r
- Function to dump information about DevicePath protocol.\r
+ Function to dump information about Partition Information protocol.\r
\r
This will allocate the return buffer from boot services pool.\r
\r
@param[in] TheHandle The handle that has the protocol installed.\r
@param[in] Verbose TRUE for additional information, FALSE otherwise.\r
\r
- @retval A poitner to a string containing the information.\r
+ @retval A pointer to a string containing the information.\r
**/\r
CHAR16*\r
EFIAPI\r
-DevicePathProtocolDumpInformation(\r
+PartitionInfoProtocolDumpInformation (\r
IN CONST EFI_HANDLE TheHandle,\r
IN CONST BOOLEAN Verbose\r
)\r
{\r
- EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
- CHAR16 *Temp;\r
- CHAR16 *Temp2;\r
- EFI_STATUS Status;\r
- Temp = NULL;\r
+ EFI_STATUS Status;\r
+ EFI_PARTITION_INFO_PROTOCOL *PartitionInfo;\r
+ CHAR16 *PartitionType;\r
+ CHAR16 *EfiSystemPartition;\r
+ CHAR16 *RetVal;\r
\r
- Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
- if (!EFI_ERROR(Status)) {\r
- //\r
- // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
- //\r
- Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);\r
- gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);\r
+ if (!Verbose) {\r
+ return NULL;\r
}\r
- if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {\r
- Temp2 = NULL;\r
- Temp2 = StrnCatGrow(&Temp2, NULL, Temp+(StrLen(Temp) - 30), 30);\r
- FreePool(Temp);\r
- Temp = Temp2;\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiPartitionInfoProtocolGuid,\r
+ (VOID**)&PartitionInfo,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return NULL;\r
}\r
- return (Temp);\r
+\r
+ HandleParsingHiiInit ();\r
+\r
+ switch (PartitionInfo->Type) {\r
+ case PARTITION_TYPE_OTHER:\r
+ PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_OTHER), NULL);\r
+ break;\r
+ case PARTITION_TYPE_MBR:\r
+ PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_MBR), NULL);\r
+ break;\r
+ case PARTITION_TYPE_GPT:\r
+ PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_TYPE_GPT), NULL);\r
+ break;\r
+ default:\r
+ PartitionType = NULL;\r
+ break;\r
+ }\r
+ if (PartitionType == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ if (PartitionInfo->System == 1) {\r
+ EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_EFI_SYS_PART), NULL);\r
+ } else {\r
+ EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_PARTINFO_DUMP_NOT_EFI_SYS_PART), NULL);\r
+ }\r
+ if (EfiSystemPartition == NULL) {\r
+ SHELL_FREE_NON_NULL (PartitionType);\r
+ return NULL;\r
+ }\r
+\r
+ RetVal = CatSPrint (\r
+ NULL,\r
+ L"%s\r\n%s",\r
+ PartitionType,\r
+ EfiSystemPartition\r
+ );\r
+\r
+ SHELL_FREE_NON_NULL (EfiSystemPartition);\r
+ SHELL_FREE_NON_NULL (PartitionType);\r
+ return RetVal;\r
}\r
\r
//\r
STATIC CONST EFI_GUID WinNtIoProtocolGuid = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;\r
STATIC CONST EFI_GUID WinNtSerialPortGuid = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;\r
\r
+//\r
+// Deprecated protocols we dont want to link from IntelFrameworkModulePkg\r
+//\r
+#define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \\r
+ { \\r
+ 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \\r
+ }\r
+#define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \\r
+ { \\r
+ 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \\r
+ }\r
+STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;\r
+STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;\r
+\r
+\r
STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {\r
{STRING_TOKEN(STR_WINNT_THUNK), (EFI_GUID*)&WinNtThunkProtocolGuid, NULL},\r
{STRING_TOKEN(STR_WINNT_DRIVER_IO), (EFI_GUID*)&WinNtIoProtocolGuid, NULL},\r
{STRING_TOKEN(STR_WINNT_SERIAL_PORT), (EFI_GUID*)&WinNtSerialPortGuid, NULL},\r
- {STRING_TOKEN(STR_UNKNOWN_DEVICE), NULL, NULL},\r
+ {0, NULL, NULL},\r
};\r
\r
STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
- {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation},\r
{STRING_TOKEN(STR_DEVICE_PATH), &gEfiDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
- {STRING_TOKEN(STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
+ {STRING_TOKEN(STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, LoadedImageDevicePathProtocolDumpInformation},\r
{STRING_TOKEN(STR_DEVICE_PATH_UTIL), &gEfiDevicePathUtilitiesProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DEVICE_PATH_TXT), &gEfiDevicePathToTextProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DEVICE_PATH_FTXT), &gEfiDevicePathFromTextProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DEVICE_PATH_VTUTF8), &gEfiVTUTF8Guid, NULL},\r
{STRING_TOKEN(STR_DRIVER_BINDING), &gEfiDriverBindingProtocolGuid, NULL},\r
{STRING_TOKEN(STR_PLATFORM_OVERRIDE), &gEfiPlatformDriverOverrideProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, BusSpecificDriverOverrideProtocolDumpInformation},\r
{STRING_TOKEN(STR_DRIVER_DIAG), &gEfiDriverDiagnosticsProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DRIVER_DIAG2), &gEfiDriverDiagnostics2ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DRIVER_CN), &gEfiComponentNameProtocolGuid, NULL},\r
{STRING_TOKEN(STR_SIM_POINTER), &gEfiSimplePointerProtocolGuid, NULL},\r
{STRING_TOKEN(STR_ABS_POINTER), &gEfiAbsolutePointerProtocolGuid, NULL},\r
{STRING_TOKEN(STR_SERIAL_IO), &gEfiSerialIoProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation},\r
+ {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, EdidDiscoveredProtocolDumpInformation},\r
+ {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, EdidActiveProtocolDumpInformation},\r
{STRING_TOKEN(STR_EDID_OVERRIDE), &gEfiEdidOverrideProtocolGuid, NULL},\r
{STRING_TOKEN(STR_CON_IN), &gEfiConsoleInDeviceGuid, NULL},\r
{STRING_TOKEN(STR_CON_OUT), &gEfiConsoleOutDeviceGuid, NULL},\r
{STRING_TOKEN(STR_SIMPLE_FILE_SYS), &gEfiSimpleFileSystemProtocolGuid, NULL},\r
{STRING_TOKEN(STR_TAPE_IO), &gEfiTapeIoProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DISK_IO), &gEfiDiskIoProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_BLK_IO), &gEfiBlockIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BLK_IO), &gEfiBlockIoProtocolGuid, BlockIoProtocolDumpInformation},\r
{STRING_TOKEN(STR_UC), &gEfiUnicodeCollationProtocolGuid, NULL},\r
{STRING_TOKEN(STR_UC2), &gEfiUnicodeCollation2ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation},\r
- {STRING_TOKEN(STR_PCI_IO), &gEfiPciIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCI_IO), &gEfiPciIoProtocolGuid, PciIoProtocolDumpInformation},\r
{STRING_TOKEN(STR_SCSI_PT), &gEfiScsiPassThruProtocolGuid, NULL},\r
{STRING_TOKEN(STR_SCSI_IO), &gEfiScsiIoProtocolGuid, NULL},\r
{STRING_TOKEN(STR_SCSI_PT_EXT), &gEfiExtScsiPassThruProtocolGuid, NULL},\r
{STRING_TOKEN(STR_ISCSI), &gEfiIScsiInitiatorNameProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_USB_IO), &gEfiUsbIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_USB_IO), &gEfiUsbIoProtocolGuid, UsbIoProtocolDumpInformation},\r
{STRING_TOKEN(STR_USB_HC), &gEfiUsbHcProtocolGuid, NULL},\r
{STRING_TOKEN(STR_USB_HC2), &gEfiUsb2HcProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, DebugSupportProtocolDumpInformation},\r
{STRING_TOKEN(STR_DEBUG_PORT), &gEfiDebugPortProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DECOMPRESS), &gEfiDecompressProtocolGuid, NULL},\r
{STRING_TOKEN(STR_ACPI_TABLE), &gEfiAcpiTableProtocolGuid, NULL},\r
{STRING_TOKEN(STR_IPV4_SB), &gEfiIp4ServiceBindingProtocolGuid, NULL},\r
{STRING_TOKEN(STR_IPV4), &gEfiIp4ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_IPV4_CFG), &gEfiIp4ConfigProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_IPV4_CFG2), &gEfiIp4Config2ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_UDPV4_SB), &gEfiUdp4ServiceBindingProtocolGuid, NULL},\r
{STRING_TOKEN(STR_UDPV4), &gEfiUdp4ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_MTFTPV4_SB), &gEfiMtftp4ServiceBindingProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DRIVER_CONFIG), &gEfiDriverConfigurationProtocolGuid, NULL},\r
{STRING_TOKEN(STR_DRIVER_CONFIG2), &gEfiDriverConfiguration2ProtocolGuid, NULL},\r
\r
+//\r
+// these are using local (non-global) definitions to reduce package dependancy.\r
+//\r
+ {STRING_TOKEN(STR_ISA_IO), (EFI_GUID*)&EfiIsaIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ISA_ACPI), (EFI_GUID*)&EfiIsaAcpiProtocolGuid, NULL},\r
+\r
//\r
// the ones under this are GUID identified structs, not protocols\r
//\r
//\r
// UEFI 2.3\r
//\r
- {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, FirmwareManagementDumpInformation},\r
{STRING_TOKEN(STR_IP_SEC), &gEfiIpSecProtocolGuid, NULL},\r
{STRING_TOKEN(STR_IP_SEC2), &gEfiIpSec2ProtocolGuid, NULL},\r
\r
{STRING_TOKEN(STR_KMS), &gEfiKmsProtocolGuid, NULL},\r
{STRING_TOKEN(STR_BLK_IO2), &gEfiBlockIo2ProtocolGuid, NULL},\r
{STRING_TOKEN(STR_SSC), &gEfiStorageSecurityCommandProtocolGuid, NULL},\r
- {STRING_TOKEN(STR_UC2), &gEfiUserCredential2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL},\r
\r
//\r
// UEFI 2.4\r
//\r
{STRING_TOKEN(STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, AdapterInformationDumpInformation},\r
+\r
+//\r
+// UEFI2.5\r
+//\r
+ {STRING_TOKEN(STR_TLS_SB), &gEfiTlsServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_TLS), &gEfiTlsProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_TLS_CONFIG), &gEfiTlsConfigurationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SUPPLICANT_SB), &gEfiSupplicantServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SUPPLICANT), &gEfiSupplicantProtocolGuid, NULL},\r
+\r
+//\r
+// UEFI2.6\r
+//\r
+ {STRING_TOKEN(STR_WIFI2), &gEfiWiFi2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RAMDISK), &gEfiRamDiskProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_HII_ID), &gEfiHiiImageDecoderProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_HII_IE), &gEfiHiiImageExProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SD_MPT), &gEfiSdMmcPassThruProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ERASE_BLOCK), &gEfiEraseBlockProtocolGuid, NULL},\r
+\r
+//\r
+// UEFI2.7\r
+//\r
+ {STRING_TOKEN(STR_BLUETOOTH_ATTR), &gEfiBluetoothAttributeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BLUETOOTH_ATTR_SB), &gEfiBluetoothAttributeServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BLUETOOTH_LE_CONFIG), &gEfiBluetoothLeConfigProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_UFS_DEV_CONFIG), &gEfiUfsDeviceConfigProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_HTTP_BOOT_CALL), &gEfiHttpBootCallbackProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RESET_NOTI), &gEfiResetNotificationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PARTITION_INFO), &gEfiPartitionInfoProtocolGuid, PartitionInfoProtocolDumpInformation},\r
+ {STRING_TOKEN(STR_HII_POPUP), &gEfiHiiPopupProtocolGuid, NULL},\r
+\r
+//\r
+// PI Spec ones\r
+//\r
+ {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL},\r
+\r
+//\r
+// PI Spec 1.0\r
+//\r
+ {STRING_TOKEN(STR_BDS_ARCH), &gEfiBdsArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_CPU_ARCH), &gEfiCpuArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MET_ARCH), &gEfiMetronomeArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MON_ARCH), &gEfiMonotonicCounterArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RTC_ARCH), &gEfiRealTimeClockArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RESET_ARCH), &gEfiResetArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RT_ARCH), &gEfiRuntimeArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SEC_ARCH), &gEfiSecurityArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_TIMER_ARCH), &gEfiTimerArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_VAR_ARCH), &gEfiVariableWriteArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_V_ARCH), &gEfiVariableArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SECP), &gEfiSecurityPolicyProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_WDT_ARCH), &gEfiWatchdogTimerArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SCR), &gEfiStatusCodeRuntimeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SMB_HC), &gEfiSmbusHcProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_FV_2), &gEfiFirmwareVolume2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_FV_BLOCK), &gEfiFirmwareVolumeBlockProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_CAP_ARCH), &gEfiCapsuleArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MP_SERVICE), &gEfiMpServiceProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_HBRAP), &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCIP), &gEfiPciPlatformProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCIO), &gEfiPciOverrideProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCIE), &gEfiPciEnumerationCompleteProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_IPCID), &gEfiIncompatiblePciDeviceSupportProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCIHPI), &gEfiPciHotPlugInitProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCIHPR), &gEfiPciHotPlugRequestProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SMBIOS), &gEfiSmbiosProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S3_SAVE), &gEfiS3SaveStateProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S3_S_SMM), &gEfiS3SmmSaveStateProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RSC), &gEfiRscHandlerProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_RSC), &gEfiSmmRscHandlerProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ACPI_SDT), &gEfiAcpiSdtProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SIO), &gEfiSioProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_CPU2), &gEfiSmmCpuIo2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_BASE2), &gEfiSmmBase2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_ACC_2), &gEfiSmmAccess2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_CON_2), &gEfiSmmControl2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_CONFIG), &gEfiSmmConfigurationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_RTL), &gEfiSmmReadyToLockProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_DS_RTL), &gEfiDxeSmmReadyToLockProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_COMM), &gEfiSmmCommunicationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_STAT), &gEfiSmmStatusCodeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_CPU), &gEfiSmmCpuProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_PCIRBIO), &gEfiSmmPciRootBridgeIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_SWD), &gEfiSmmSwDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_SXD), &gEfiSmmSxDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_PTD2), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_UD2), &gEfiSmmUsbDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_GD2), &gEfiSmmGpiDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_SBD2), &gEfiSmmStandbyButtonDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_PBD2), &gEfiSmmPowerButtonDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S_ITD2), &gEfiSmmIoTrapDispatch2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PCD), &gEfiPcdProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_FVB2), &gEfiFirmwareVolumeBlock2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_CPUIO2), &gEfiCpuIo2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_LEGACY_R2), &gEfiLegacyRegion2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_S2ARCH), &gEfiSecurity2ArchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_EODXE), &gEfiSmmEndOfDxeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ISAHC), &gEfiIsaHcProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_ISAHC_B), &gEfiIsaHcServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SIO_C), &gEfiSioControlProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_GET_PCD), &gEfiGetPcdInfoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_I2C_M), &gEfiI2cMasterProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_I2CIO), &gEfiI2cIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_I2CEN), &gEfiI2cEnumerateProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_I2C_H), &gEfiI2cHostProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_I2C_BCM), &gEfiI2cBusConfigurationManagementProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_TCG2), &gEfiTcg2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_TIMESTAMP), &gEfiTimestampProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_RNG), &gEfiRngProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NVMEPT), &gEfiNvmExpressPassThruProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_H2_SB), &gEfiHash2ServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_HASH2), &gEfiHash2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BIO_C), &gEfiBlockIoCryptoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SCR), &gEfiSmartCardReaderProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SCE), &gEfiSmartCardEdgeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_USB_FIO), &gEfiUsbFunctionIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BC_HC), &gEfiBluetoothHcProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BC_IO_SB), &gEfiBluetoothIoServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BC_IO), &gEfiBluetoothIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_BC_C), &gEfiBluetoothConfigProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_REG_EXP), &gEfiRegularExpressionProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_B_MGR_P), &gEfiBootManagerPolicyProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_CKH), &gEfiConfigKeywordHandlerProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_WIFI), &gEfiWiFiProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_EAP_M), &gEfiEapManagement2ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_EAP_C), &gEfiEapConfigurationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_PKCS7), &gEfiPkcs7VerifyProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_DNS4_SB), &gEfiDns4ServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_DNS4), &gEfiDns4ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_DNS6_SB), &gEfiDns6ServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_DNS6), &gEfiDns6ProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_HTTP_SB), &gEfiHttpServiceBindingProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_HTTP), &gEfiHttpProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_NET_HTTP_U), &gEfiHttpUtilitiesProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_REST), &gEfiRestProtocolGuid, NULL},\r
+\r
+//\r
+// PI 1.5\r
+//\r
+ {STRING_TOKEN(STR_MM_EOD), &gEfiMmEndOfDxeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_ITD), &gEfiMmIoTrapDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_PBD), &gEfiMmPowerButtonDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_SBD), &gEfiMmStandbyButtonDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_GD), &gEfiMmGpiDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_UD), &gEfiMmUsbDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_PTD), &gEfiMmPeriodicTimerDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_SXD), &gEfiMmSxDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_SWD), &gEfiMmSwDispatchProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_PRBI), &gEfiMmPciRootBridgeIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_CPU), &gEfiMmCpuProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_STACODE), &gEfiMmStatusCodeProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_DXEMM_RTL), &gEfiDxeMmReadyToLockProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_CONFIG), &gEfiMmConfigurationProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_RTL), &gEfiMmReadyToLockProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_CONTROL), &gEfiMmControlProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_ACCESS), &gEfiMmAccessProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_BASE), &gEfiMmBaseProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_CPUIO), &gEfiMmCpuIoProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_RH), &gEfiMmRscHandlerProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_MM_COM), &gEfiMmCommunicationProtocolGuid, NULL},\r
+\r
+//\r
+// UEFI Shell Spec 2.0\r
+//\r
+ {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
+ {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
+\r
+//\r
+// UEFI Shell Spec 2.1\r
+//\r
+ {STRING_TOKEN(STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL},\r
+\r
+//\r
+// Misc\r
+//\r
+ {STRING_TOKEN(STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL},\r
\r
//\r
// terminator\r
//\r
- {STRING_TOKEN(STR_UNKNOWN_DEVICE), NULL, NULL},\r
+ {0, NULL, NULL},\r
};\r
\r
/**\r
@return The node.\r
**/\r
CONST GUID_INFO_BLOCK *\r
-EFIAPI\r
InternalShellGetNodeFromGuid(\r
IN CONST EFI_GUID* Guid\r
)\r
{\r
CONST GUID_INFO_BLOCK *ListWalker;\r
+ UINTN LoopCount;\r
\r
ASSERT(Guid != NULL);\r
\r
+ for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
+ if (CompareGuid(ListWalker->GuidId, Guid)) {\r
+ return (ListWalker);\r
+ }\r
+ }\r
+\r
if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
if (CompareGuid(ListWalker->GuidId, Guid)) {\r
return (ListWalker);\r
}\r
}\r
- return (ListWalker);\r
+ return (NULL);\r
+}\r
+\r
+/**\r
+Function to add a new GUID/Name mapping.\r
+\r
+@param[in] Guid The Guid\r
+@param[in] NameID The STRING id of the HII string to use\r
+@param[in] DumpFunc The pointer to the dump function\r
+\r
+\r
+@retval EFI_SUCCESS The operation was sucessful\r
+@retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
+@retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
+**/\r
+EFI_STATUS\r
+InsertNewGuidNameMapping(\r
+ IN CONST EFI_GUID *Guid,\r
+ IN CONST EFI_STRING_ID NameID,\r
+ IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL\r
+ )\r
+{\r
+ ASSERT(Guid != NULL);\r
+ ASSERT(NameID != 0);\r
+\r
+ mGuidList = ReallocatePool(mGuidListCount * sizeof(GUID_INFO_BLOCK), mGuidListCount+1 * sizeof(GUID_INFO_BLOCK), mGuidList);\r
+ if (mGuidList == NULL) {\r
+ mGuidListCount = 0;\r
+ return (EFI_OUT_OF_RESOURCES);\r
+ }\r
+ mGuidListCount++;\r
+\r
+ mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool(sizeof(EFI_GUID), Guid);\r
+ mGuidList[mGuidListCount - 1].StringId = NameID;\r
+ mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r
+\r
+ if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r
+ return (EFI_OUT_OF_RESOURCES);\r
+ }\r
+\r
+ return (EFI_SUCCESS);\r
+}\r
+\r
+/**\r
+ Function to add a new GUID/Name mapping.\r
+\r
+ This cannot overwrite an existing mapping.\r
+\r
+ @param[in] Guid The Guid\r
+ @param[in] TheName The Guid's name\r
+ @param[in] Lang RFC4646 language code list or NULL\r
+\r
+ @retval EFI_SUCCESS The operation was sucessful\r
+ @retval EFI_ACCESS_DENIED There was a duplicate\r
+ @retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
+ @retval EFI_INVALID_PARAMETER Guid or TheName was NULL\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+AddNewGuidNameMapping(\r
+ IN CONST EFI_GUID *Guid,\r
+ IN CONST CHAR16 *TheName,\r
+ IN CONST CHAR8 *Lang OPTIONAL\r
+ )\r
+{\r
+ EFI_STRING_ID NameID;\r
+\r
+ HandleParsingHiiInit();\r
+\r
+ if (Guid == NULL || TheName == NULL){\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {\r
+ return (EFI_ACCESS_DENIED);\r
+ }\r
+\r
+ NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);\r
+ if (NameID == 0) {\r
+ return (EFI_OUT_OF_RESOURCES);\r
+ }\r
+\r
+ return (InsertNewGuidNameMapping(Guid, NameID, NULL));\r
}\r
\r
/**\r
{\r
CONST GUID_INFO_BLOCK *Id;\r
\r
+ HandleParsingHiiInit();\r
+\r
Id = InternalShellGetNodeFromGuid(Guid);\r
- return (HiiGetString(mHandleParsingHiiHandle, Id->StringId, Lang));\r
+ if (Id == NULL) {\r
+ return NULL;\r
+ }\r
+ return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r
}\r
\r
/**\r
/**\r
Function to get the Guid for a protocol or struct based on it's string name.\r
\r
+ do not modify the returned Guid.\r
+\r
@param[in] Name The pointer to the string name.\r
@param[in] Lang The pointer to the language code.\r
- @param[in] Guid The pointer to the Guid.\r
+ @param[out] Guid The pointer to the Guid.\r
\r
@retval EFI_SUCCESS The operation was sucessful.\r
**/\r
GetGuidFromStringName(\r
IN CONST CHAR16 *Name,\r
IN CONST CHAR8 *Lang OPTIONAL,\r
- IN EFI_GUID **Guid\r
+ OUT EFI_GUID **Guid\r
)\r
{\r
CONST GUID_INFO_BLOCK *ListWalker;\r
CHAR16 *String;\r
+ UINTN LoopCount;\r
+\r
+ HandleParsingHiiInit();\r
\r
ASSERT(Guid != NULL);\r
if (Guid == NULL) {\r
return (EFI_SUCCESS);\r
}\r
}\r
+\r
+ for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
+ String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
+ if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
+ *Guid = ListWalker->GuidId;\r
+ }\r
+ SHELL_FREE_NON_NULL(String);\r
+ if (*Guid != NULL) {\r
+ return (EFI_SUCCESS);\r
+ }\r
+ }\r
+\r
return (EFI_NOT_FOUND);\r
}\r
\r
/**\r
Get best support language for this driver.\r
- \r
- First base on the user input language to search, second base on the current \r
- platform used language to search, third get the first language from the \r
+\r
+ First base on the user input language to search, second base on the current\r
+ platform used language to search, third get the first language from the\r
support language list. The caller need to free the buffer of the best language.\r
\r
@param[in] SupportedLanguages The support languages for this driver.\r
CHAR8 *LanguageVariable;\r
CHAR8 *BestLanguage;\r
\r
- LanguageVariable = GetVariable (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid);\r
+ GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);\r
\r
BestLanguage = GetBestLanguage(\r
SupportedLanguages,\r
@retval EFI_SUCCESS The operation was successful.\r
**/\r
EFI_STATUS\r
-EFIAPI\r
InternalShellInitHandleList(\r
VOID\r
)\r
}\r
for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
- ASSERT(ListWalker != NULL);\r
- ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex-1];\r
- ListWalker->TheIndex = mHandleList.NextIndex;\r
- InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
+ if (ListWalker != NULL) {\r
+ ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
+ ListWalker->TheIndex = mHandleList.NextIndex;\r
+ InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
+ }\r
}\r
FreePool(HandleBuffer);\r
return (EFI_SUCCESS);\r
FreePool (ProtocolBuffer);\r
\r
ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
- ASSERT(ListWalker != NULL);\r
+ if (ListWalker == NULL) {\r
+ return 0;\r
+ }\r
ListWalker->TheHandle = TheHandle;\r
ListWalker->TheIndex = mHandleList.NextIndex++;\r
InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
// Verify that LinkWalker->TheHandle is valid handle\r
//\r
Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
- if (EFI_ERROR (Status)) {\r
+ if (!EFI_ERROR (Status)) {\r
+ FreePool (ProtocolBuffer);\r
+ } else {\r
//\r
// TheHandle is not valid, so do not add to handle list\r
//\r
}\r
\r
*HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
- ASSERT(*HandleType != NULL);\r
+ if (*HandleType == NULL) {\r
+ SHELL_FREE_NON_NULL (*HandleBuffer);\r
+ *HandleCount = 0;\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
\r
DriverBindingHandleIndex = -1;\r
for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
// Set the bit describing what this handle has\r
//\r
if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_IMAGE_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_DRIVER_BINDING_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
- (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
} else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
- (*HandleType)[HandleIndex] |= HR_DEVICE_HANDLE;\r
- } else {\r
- DEBUG_CODE_BEGIN();\r
- ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);\r
- DEBUG_CODE_END();\r
+ (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
}\r
//\r
// Retrieve the list of agents that have opened each protocol\r
\r
if (ControllerHandle == NULL) {\r
//\r
- // ControllerHandle == NULL and DriverBindingHandle != NULL. \r
+ // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
// Return information on all the controller handles that the driver specified by DriverBindingHandle is managing\r
//\r
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
if (DriverBindingHandleIndex != -1) {\r
- (*HandleType)[DriverBindingHandleIndex] |= HR_DEVICE_DRIVER;\r
+ (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
}\r
}\r
if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
if (DriverBindingHandleIndex != -1) {\r
- (*HandleType)[DriverBindingHandleIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
+ (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
}\r
for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
+ (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
}\r
}\r
}\r
}\r
if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= HR_DEVICE_DRIVER;\r
+ (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
}\r
}\r
}\r
if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
+ (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
}\r
if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
+ (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
}\r
}\r
}\r
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
}\r
}\r
}\r
}\r
if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
if (DriverBindingHandleIndex != -1) {\r
- (*HandleType)[DriverBindingHandleIndex] |= HR_DEVICE_DRIVER;\r
+ (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
}\r
}\r
}\r
if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
+ (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
}\r
}\r
}\r
\r
for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
- (*HandleType)[ChildIndex] |= (HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
+ (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
}\r
}\r
}\r
for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
- (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
+ (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
}\r
}\r
}\r
// Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
//\r
*MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
- ASSERT(*MatchingHandleBuffer != NULL);\r
+ if (*MatchingHandleBuffer == NULL) {\r
+ Status = EFI_OUT_OF_RESOURCES;\r
+ } else {\r
+ for (HandleIndex = 0, *MatchingHandleCount = 0\r
+ ; HandleIndex < HandleCount\r
+ ; HandleIndex++\r
+ ) {\r
+ //\r
+ // Fill the allocated buffer with the handles that matched the attributes in Mask\r
+ //\r
+ if ((HandleType[HandleIndex] & Mask) == Mask) {\r
+ (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
+ }\r
+ }\r
\r
- for (HandleIndex = 0,*MatchingHandleCount = 0\r
- ; HandleIndex < HandleCount\r
- ; HandleIndex++\r
- ){\r
//\r
- // Fill the allocated buffer with the handles that matched the attributes in Mask\r
+ // Make the last one NULL\r
//\r
- if ((HandleType[HandleIndex] & Mask) == Mask) {\r
- (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
- }\r
- }\r
-\r
- //\r
- // Make the last one NULL\r
- //\r
- (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
+ (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
\r
- Status = EFI_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ } // *MatchingHandleBuffer == NULL (ELSE)\r
} // MacthingHandleBuffer == NULL (ELSE)\r
} // *MatchingHandleCount == 0 (ELSE)\r
} // no error on ParseHandleDatabaseByRelationshipWithType\r
FreePool (HandleType);\r
}\r
\r
+ ASSERT ((MatchingHandleBuffer == NULL) ||\r
+ (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
+ (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
return Status;\r
}\r
\r
Gets handles for any child controllers of the passed in controller.\r
\r
@param[in] ControllerHandle The handle of the "parent controller"\r
- @param[in] MatchingHandleCount Pointer to the number of handles in\r
+ @param[out] MatchingHandleCount Pointer to the number of handles in\r
MatchingHandleBuffer on return.\r
@param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
return.\r
EFIAPI\r
ParseHandleDatabaseForChildControllers(\r
IN CONST EFI_HANDLE ControllerHandle,\r
- IN UINTN *MatchingHandleCount,\r
+ OUT UINTN *MatchingHandleCount,\r
OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
)\r
{\r
\r
FreePool (DriverBindingHandleBuffer);\r
\r
+ if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {\r
+ //\r
+ // The caller is not interested in the actual handles, or we've found none.\r
+ //\r
+ FreePool (HandleBufferForReturn);\r
+ HandleBufferForReturn = NULL;\r
+ }\r
+\r
if (MatchingHandleBuffer != NULL) {\r
*MatchingHandleBuffer = HandleBufferForReturn;\r
- } else {\r
- FreePool(HandleBufferForReturn);\r
}\r
\r
+ ASSERT ((MatchingHandleBuffer == NULL) ||\r
+ (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
+ (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
+\r
return (EFI_SUCCESS);\r
}\r
\r
@return A pointer to (*DestinationBuffer).\r
**/\r
VOID*\r
-EFIAPI\r
BuffernCatGrow (\r
IN OUT VOID **DestinationBuffer,\r
IN OUT UINTN *DestinationSize,\r
}\r
\r
//\r
- // No handles were found... \r
+ // No handles were found...\r
//\r
if (TotalSize == sizeof(EFI_HANDLE)) {\r
return (NULL);\r
return (HandleList);\r
}\r
\r
+/**\r
+ Return all supported GUIDs.\r
\r
+ @param[out] Guids The buffer to return all supported GUIDs.\r
+ @param[in, out] Count On input, the count of GUIDs the buffer can hold,\r
+ On output, the count of GUIDs to return.\r
\r
+ @retval EFI_INVALID_PARAMETER Count is NULL.\r
+ @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.\r
+ @retval EFI_SUCCESS GUIDs are returned successfully.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+GetAllMappingGuids (\r
+ OUT EFI_GUID *Guids,\r
+ IN OUT UINTN *Count\r
+ )\r
+{\r
+ UINTN GuidCount;\r
+ UINTN NtGuidCount;\r
+ UINTN Index;\r
\r
+ if (Count == NULL) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
\r
+ NtGuidCount = 0;\r
+ if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
+ NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;\r
+ }\r
+ GuidCount = ARRAY_SIZE (mGuidStringList) - 1;\r
\r
+ if (*Count < NtGuidCount + GuidCount + mGuidListCount) {\r
+ *Count = NtGuidCount + GuidCount + mGuidListCount;\r
+ return EFI_BUFFER_TOO_SMALL;\r
+ }\r
\r
+ for (Index = 0; Index < NtGuidCount; Index++) {\r
+ CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);\r
+ }\r
\r
+ for (Index = 0; Index < GuidCount; Index++) {\r
+ CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);\r
+ }\r
\r
+ for (Index = 0; Index < mGuidListCount; Index++) {\r
+ CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);\r
+ }\r
\r
+ return EFI_SUCCESS;\r
+}\r
projects / mirror_edk2.git / blobdiff