--- /dev/null
+/** @file\r
+ Main file for connect shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+/**\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ConnectControllers (\r
+ IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
+ IN CONST EFI_HANDLE DriverHandle OPTIONAL,\r
+ IN CONST BOOLEAN Recursive,\r
+ IN CONST BOOLEAN Output,\r
+ IN CONST BOOLEAN AlwaysOutput\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_STATUS Status2;\r
+ EFI_HANDLE *ControllerHandleList;\r
+ EFI_HANDLE *DriverHandleList;\r
+ EFI_HANDLE *HandleWalker;\r
+\r
+ ControllerHandleList = NULL;\r
+ Status = EFI_NOT_FOUND;\r
+ Status2 = EFI_NOT_FOUND;\r
+\r
+ //\r
+ // If we have a single handle to connect make that a 'list'\r
+ //\r
+ if (DriverHandle == NULL) {\r
+ DriverHandleList = NULL;\r
+ } else {\r
+ DriverHandleList = AllocatePool(2*sizeof(EFI_HANDLE));\r
+ if (DriverHandleList == NULL) {\r
+ return (EFI_OUT_OF_RESOURCES);\r
+ }\r
+ DriverHandleList[0] = DriverHandle;\r
+ DriverHandleList[1] = NULL;\r
+ }\r
+\r
+ //\r
+ // do we connect all controllers (with a loop) or a single one...\r
+ // This is where we call the gBS->ConnectController function.\r
+ //\r
+ if (ControllerHandle == NULL) {\r
+ ControllerHandleList = GetHandleListByProtocol(&gEfiDevicePathProtocolGuid);\r
+ for (HandleWalker = ControllerHandleList\r
+ ; HandleWalker != NULL && *HandleWalker != NULL\r
+ ; HandleWalker++\r
+ ){\r
+ Status = gBS->ConnectController(*HandleWalker, DriverHandleList, NULL, Recursive);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status2 = EFI_SUCCESS;\r
+ }\r
+ if ((Output && !EFI_ERROR(Status)) || AlwaysOutput) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex(*HandleWalker), Status);\r
+ }\r
+ }\r
+ } else {\r
+ Status = gBS->ConnectController(ControllerHandle, DriverHandleList, NULL, Recursive);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status2 = EFI_SUCCESS;\r
+ }\r
+ if ((Output && !EFI_ERROR(Status)) || AlwaysOutput) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex(ControllerHandle), Status);\r
+ }\r
+ }\r
+\r
+ //\r
+ // Free any memory we allocated.\r
+ //\r
+ if (ControllerHandleList != NULL) {\r
+ FreePool(ControllerHandleList);\r
+ }\r
+ if (DriverHandleList != NULL) {\r
+ FreePool(DriverHandleList);\r
+ }\r
+ return (Status2);\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+ConnectFromDevPaths (\r
+ IN CONST CHAR16 *Key\r
+ )\r
+{\r
+ EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
+ EFI_DEVICE_PATH_PROTOCOL *DevPathWalker;\r
+ UINTN Length;\r
+ EFI_HANDLE Handle;\r
+ EFI_STATUS Status;\r
+\r
+ DevPath = NULL;\r
+ Length = 0;\r
+\r
+ //\r
+ // Get the DevicePath buffer from the variable...\r
+ //\r
+ Status = gRT->GetVariable((CHAR16*)Key, (EFI_GUID*)&gEfiGlobalVariableGuid, NULL, &Length, DevPath);\r
+ if (Status == EFI_BUFFER_TOO_SMALL) {\r
+ DevPath = AllocatePool(Length);\r
+ Status = gRT->GetVariable((CHAR16*)Key, (EFI_GUID*)&gEfiGlobalVariableGuid, NULL, &Length, DevPath);\r
+ }\r
+\r
+ Status = EFI_NOT_FOUND;\r
+ //\r
+ // walk the list of devices and connect them\r
+ //\r
+ for (DevPathWalker = DevPath\r
+ ; DevPathWalker < (DevPath + Length) && EFI_ERROR(Status) && DevPath != NULL\r
+ ; DevPathWalker += GetDevicePathSize(DevPathWalker)\r
+ ){\r
+ //\r
+ // get the correct handle from a given device path\r
+ //\r
+ if ((StrCmp(Key, L"ConInDev") == 0)\r
+ ||(StrCmp(Key, L"ConIn") == 0)\r
+ ){\r
+ Status = gBS->LocateDevicePath((EFI_GUID*)&gEfiConsoleInDeviceGuid, &DevPathWalker, &Handle);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = ConnectControllers(NULL, Handle, FALSE, TRUE, FALSE);\r
+ }\r
+ } else if ((StrCmp(Key, L"ConOutDev") == 0) \r
+ || (StrCmp(Key, L"ConErrDev") == 0) \r
+ || (StrCmp(Key, L"ConOut") == 0) \r
+ || (StrCmp(Key, L"ConErr") == 0)\r
+ ){\r
+ Status = gBS->LocateDevicePath((EFI_GUID*)&gEfiConsoleOutDeviceGuid, &DevPathWalker, &Handle);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = ConnectControllers(NULL, Handle, FALSE, TRUE, FALSE);\r
+ }\r
+ }\r
+ }\r
+\r
+ if (DevPath != NULL) {\r
+ FreePool(DevPath);\r
+ }\r
+ return (Status);\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+ConvertAndConnectControllers (\r
+ IN CONST CHAR16 *StringHandle1 OPTIONAL,\r
+ IN CONST CHAR16 *StringHandle2 OPTIONAL,\r
+ IN CONST BOOLEAN Recursive,\r
+ IN CONST BOOLEAN Output\r
+ )\r
+{\r
+ EFI_HANDLE Handle1;\r
+ EFI_HANDLE Handle2;\r
+\r
+ //\r
+ // Convert the command line parameters to HANDLES. They must be in HEX according to spec.\r
+ //\r
+ if (StringHandle1 != NULL) {\r
+ Handle1 = ConvertHandleIndexToHandle(StrHexToUintn(StringHandle1));\r
+ } else {\r
+ Handle1 = NULL;\r
+ }\r
+ if (StringHandle2 != NULL) {\r
+ Handle2 = ConvertHandleIndexToHandle(StrHexToUintn(StringHandle2));\r
+ } else {\r
+ Handle2 = NULL;\r
+ }\r
+\r
+ //\r
+ // if only one is NULL verify it's the proper one...\r
+ //\r
+ if ( (Handle1 == NULL && Handle2 != NULL)\r
+ || (Handle1 != NULL && Handle2 == NULL)\r
+ ){\r
+ //\r
+ // Figure out which one should be NULL and move the handle to the right place.\r
+ // If Handle1 is NULL then test Handle2 and vise versa.\r
+ // The one that DOES has driver binding must be Handle2\r
+ //\r
+ if (Handle1 == NULL) {\r
+ if (EFI_ERROR(gBS->OpenProtocol(Handle2, &gEfiDriverBindingProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ // swap\r
+ Handle1 = Handle2;\r
+ Handle2 = NULL;\r
+ } else {\r
+ // We're all good...\r
+ }\r
+ } else {\r
+ if (EFI_ERROR(gBS->OpenProtocol(Handle1, &gEfiDriverBindingProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ // We're all good...\r
+ } else {\r
+ // swap\r
+ Handle2 = Handle1;\r
+ Handle1 = NULL;\r
+ }\r
+ }\r
+ }\r
+\r
+ return (ConnectControllers(Handle1, Handle2, Recursive, Output, FALSE));\r
+}\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-c", TypeFlag},\r
+ {L"-r", TypeFlag},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+/**\r
+ Function for 'connect' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunConnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CONST CHAR16 *Param1;\r
+ CONST CHAR16 *Param2;\r
+ UINTN Count;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ //\r
+ // if more than 2 'value' parameters (plus the name one) or either -r or -c with any value parameters we have too many parameters\r
+ //\r
+ if ((ShellCommandLineGetCount(Package) > 3)\r
+ ||((ShellCommandLineGetFlag(Package, L"-r") || ShellCommandLineGetFlag(Package, L"-c")) && ShellCommandLineGetCount(Package)>1)\r
+ ||(ShellCommandLineGetFlag(Package, L"-r") && ShellCommandLineGetFlag(Package, L"-c") )\r
+ ){\r
+ //\r
+ // error for too many parameters\r
+ //\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetFlag(Package, L"-c")) {\r
+ //\r
+ // do the conin and conout from EFI variables\r
+ // if the first fails dont 'loose' the error\r
+ //\r
+ Status = ConnectFromDevPaths(L"ConInDev");\r
+ if (EFI_ERROR(Status)) {\r
+ ConnectFromDevPaths(L"ConOutDev");\r
+ } else {\r
+ Status = ConnectFromDevPaths(L"ConOutDev");\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ ConnectFromDevPaths(L"ConErrDev");\r
+ } else {\r
+ Status = ConnectFromDevPaths(L"ConErrDev");\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ ConnectFromDevPaths(L"ConErr");\r
+ } else {\r
+ Status = ConnectFromDevPaths(L"ConErr");\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ ConnectFromDevPaths(L"ConIn");\r
+ } else {\r
+ Status = ConnectFromDevPaths(L"ConIn");\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ ConnectFromDevPaths(L"ConOut");\r
+ } else {\r
+ Status = ConnectFromDevPaths(L"ConOut");\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ ShellStatus = SHELL_DEVICE_ERROR;\r
+ }\r
+ } else {\r
+ //\r
+ // 0, 1, or 2 specific handles and possibly recursive\r
+ //\r
+ Param1 = ShellCommandLineGetRawValue(Package, 1);\r
+ Param2 = ShellCommandLineGetRawValue(Package, 2);\r
+ Count = ShellCommandLineGetCount(Package);\r
+ if (Param1 != NULL && ConvertHandleIndexToHandle(StrHexToUintn(Param1)) == NULL){\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param1);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (Param2 != NULL && ConvertHandleIndexToHandle(StrHexToUintn(Param2)) == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param2);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ Status = ConvertAndConnectControllers(Param1, Param2, ShellCommandLineGetFlag(Package, L"-r"), (BOOLEAN)(Count!=0));\r
+ if (EFI_ERROR(Status)) {\r
+ ShellStatus = SHELL_DEVICE_ERROR;\r
+ }\r
+ }\r
+ }\r
+\r
+ ShellCommandLineFreeVarList (Package);\r
+ }\r
+ return (ShellStatus);\r
+}\r
+\r
--- /dev/null
+/** @file\r
+ Main file for DevTree shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-d", TypeFlag},\r
+ {L"-l", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+DoDevTreeForHandle(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST CHAR8 *Lang OPTIONAL,\r
+ IN CONST BOOLEAN UseDevPaths,\r
+ IN CONST UINTN IndentCharCount,\r
+ IN CONST CHAR16 *HiiString\r
+ )\r
+{\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_STATUS Status;\r
+ CHAR16 *FormatString;\r
+ CHAR16 *Name;\r
+ EFI_HANDLE *ChildHandleBuffer;\r
+ UINTN ChildCount;\r
+ UINTN LoopVar;\r
+\r
+ Status = EFI_SUCCESS;\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Name = NULL;\r
+ ChildHandleBuffer = NULL;\r
+ ChildCount = 0;\r
+\r
+ ASSERT(TheHandle != NULL);\r
+ //\r
+ // We want controller handles. they will not have LoadedImage or DriverBinding (or others...)\r
+ //\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiDriverBindingProtocolGuid,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ return SHELL_SUCCESS;\r
+ }\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ return SHELL_SUCCESS;\r
+ }\r
+\r
+ //\r
+ // If we are at the begining then we want root handles they have no parents and do have device path.\r
+ //\r
+ if (IndentCharCount == 0) {\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiDevicePathProtocolGuid,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return SHELL_SUCCESS;\r
+ }\r
+ }\r
+\r
+ FormatString = AllocateZeroPool(StrSize(HiiString) + (10)*sizeof(FormatString[0]));\r
+\r
+ ASSERT(HiiString != NULL);\r
+ ASSERT(FormatString != NULL);\r
+\r
+ //\r
+ // we generate the format string on the fly so that we can control the\r
+ // number of space characters that the first (empty) string has. this\r
+ // handles the indenting.\r
+ //\r
+\r
+ UnicodeSPrint(FormatString, StrSize(HiiString) + (10)*sizeof(FormatString[0]), L"%%%ds %s", IndentCharCount, HiiString);\r
+ gEfiShellProtocol->GetDeviceName((EFI_HANDLE)TheHandle, !UseDevPaths?EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH:EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Lang, &Name);\r
+ //\r
+ // print out the information for ourselves\r
+ //\r
+ ShellPrintEx(\r
+ -1,\r
+ -1,\r
+ FormatString,\r
+ L"",\r
+ ConvertHandleToHandleIndex(TheHandle),\r
+ Name==NULL?L"Unknown":Name);\r
+\r
+ FreePool(FormatString);\r
+ if (Name != NULL) {\r
+ FreePool(Name);\r
+ }\r
+\r
+ //\r
+ // recurse on each child handle with IndentCharCount + 2\r
+ //\r
+ ParseHandleDatabaseForChildControllers(TheHandle, &ChildCount, &ChildHandleBuffer);\r
+ for (LoopVar = 0 ; LoopVar < ChildCount && ShellStatus == SHELL_SUCCESS; LoopVar++){\r
+ ShellStatus = DoDevTreeForHandle(ChildHandleBuffer[LoopVar], Lang, UseDevPaths, IndentCharCount+2, HiiString);\r
+ }\r
+\r
+ if (ChildHandleBuffer != NULL) {\r
+ FreePool(ChildHandleBuffer);\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
+\r
+/**\r
+ Function for 'devtree' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDevTree (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CHAR8 *Language;\r
+ CONST CHAR16 *Lang;\r
+ CHAR16 *HiiString;\r
+ UINTN LoopVar;\r
+ EFI_HANDLE TheHandle;\r
+ BOOLEAN FlagD;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ Language = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 2) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ ASSERT(Language == NULL);\r
+// Language = AllocateZeroPool(10);\r
+// AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+ FlagD = ShellCommandLineGetFlag(Package, L"-d");\r
+\r
+ Lang = ShellCommandLineGetRawValue(Package, 1);\r
+ HiiString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN (STR_DEV_TREE_OUTPUT), Language);\r
+\r
+ if (Lang == NULL) {\r
+ for (LoopVar = 1 ; ; LoopVar++){\r
+ TheHandle = ConvertHandleIndexToHandle(LoopVar);\r
+ if (TheHandle == NULL){\r
+ break;\r
+ }\r
+ ShellStatus = DoDevTreeForHandle(TheHandle, Language, FlagD, 0, HiiString);\r
+ }\r
+ } else {\r
+ if (!ShellIsHexOrDecimalNumber(Lang, TRUE, FALSE) || ConvertHandleIndexToHandle(StrHexToUintn(Lang)) == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Lang);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ShellStatus = DoDevTreeForHandle(ConvertHandleIndexToHandle(StrHexToUintn(Lang)), Language, FlagD, 0, HiiString);\r
+ }\r
+ }\r
+\r
+ if (HiiString != NULL) {\r
+ FreePool(HiiString);\r
+ }\r
+ SHELL_FREE_NON_NULL(Language);\r
+ ShellCommandLineFreeVarList (Package);\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for devices shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+GetDeviceHandleInfo (\r
+ IN EFI_HANDLE TheHandle,\r
+ IN CHAR16 *Type,\r
+ IN BOOLEAN *Cfg,\r
+ IN BOOLEAN *Diag,\r
+ IN UINTN *Parents,\r
+ IN UINTN *Devices,\r
+ IN UINTN *Children,\r
+ OUT CHAR16 **Name,\r
+ IN CONST CHAR8 *Language\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_HANDLE *HandleBuffer;\r
+ UINTN Count;\r
+\r
+ if (TheHandle == NULL \r
+ || Type == NULL\r
+ || Cfg == NULL\r
+ || Diag == NULL\r
+ || Parents == NULL\r
+ || Devices == NULL\r
+ || Children == NULL\r
+ || Name == NULL ) {\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ *Cfg = FALSE;\r
+ *Diag = FALSE;\r
+ *Children = 0;\r
+ *Parents = 0;\r
+ *Devices = 0;\r
+ *Type = L' ';\r
+ *Name = CHAR_NULL;\r
+ HandleBuffer = NULL;\r
+ Status = EFI_SUCCESS;\r
+\r
+ gEfiShellProtocol->GetDeviceName(TheHandle, EFI_DEVICE_NAME_USE_COMPONENT_NAME|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, Name);\r
+\r
+ Status = ParseHandleDatabaseForChildControllers(TheHandle, Children, NULL);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = PARSE_HANDLE_DATABASE_PARENTS(TheHandle, Parents, NULL);\r
+ if (/*!EFI_ERROR(Status) && */Parents != NULL && Children != NULL) {\r
+ if (*Parents == 0) {\r
+ *Type = L'R';\r
+ } else if (*Children > 0) {\r
+ *Type = L'B';\r
+ } else {\r
+ *Type = L'D';\r
+ }\r
+ }\r
+ }\r
+ Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS(TheHandle, Devices, &HandleBuffer);\r
+ if (!EFI_ERROR(Status) && Devices != NULL && HandleBuffer != NULL) {\r
+ for (Count = 0 ; Count < *Devices ; Count++) {\r
+ if (!EFI_ERROR(gBS->OpenProtocol(HandleBuffer[Count], &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ *Cfg = TRUE;\r
+ }\r
+ if (!EFI_ERROR(gBS->OpenProtocol(HandleBuffer[Count], &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ *Diag = TRUE;\r
+ }\r
+ if (!EFI_ERROR(gBS->OpenProtocol(HandleBuffer[Count], &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ *Diag = TRUE;\r
+ }\r
+ }\r
+ SHELL_FREE_NON_NULL(HandleBuffer);\r
+ }\r
+\r
+ return (Status);\r
+}\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-l", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+/**\r
+ Function for 'devices' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDevices (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CHAR8 *Language;\r
+ EFI_HANDLE *HandleList;\r
+ EFI_HANDLE *HandleListWalker;\r
+ CHAR16 Type;\r
+ BOOLEAN Cfg;\r
+ BOOLEAN Diag;\r
+ UINTN Parents;\r
+ UINTN Devices;\r
+ UINTN Children;\r
+ CHAR16 *Name;\r
+ CONST CHAR16 *Lang;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Language = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ //\r
+ // if more than 0 'value' parameters we have too many parameters\r
+ //\r
+ if (ShellCommandLineGetRawValue(Package, 1) != NULL){\r
+ //\r
+ // error for too many parameters\r
+ //\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ //\r
+ // get the language if necessary\r
+ //\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ ASSERT(Language == NULL);\r
+// Language = AllocateZeroPool(10);\r
+// AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+\r
+ //\r
+ // Print Header\r
+ //\r
+ ShellPrintHiiEx(-1, -1, Language, STRING_TOKEN (STR_DEVICES_HEADER_LINES), gShellDriver1HiiHandle);\r
+\r
+ //\r
+ // loop through each handle\r
+ //\r
+ HandleList = GetHandleListByProtocol(NULL);\r
+ ASSERT(HandleList != NULL);\r
+ for (HandleListWalker = HandleList\r
+ ; HandleListWalker != NULL && *HandleListWalker != NULL /*&& !EFI_ERROR(Status)*/\r
+ ; HandleListWalker++\r
+ ){\r
+\r
+ //\r
+ // get all the info on each handle\r
+ //\r
+ Name = NULL;\r
+ Status = GetDeviceHandleInfo(*HandleListWalker, &Type, &Cfg, &Diag, &Parents, &Devices, &Children, &Name, Language);\r
+ if (Parents != 0 || Devices != 0 || Children != 0) {\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ Language,\r
+ STRING_TOKEN (STR_DEVICES_ITEM_LINE),\r
+ gShellDriver1HiiHandle,\r
+ ConvertHandleToHandleIndex(*HandleListWalker),\r
+ Type,\r
+ Cfg?L'X':L'-',\r
+ Diag?L'X':L'-',\r
+ Parents,\r
+ Devices,\r
+ Children,\r
+ Name!=NULL?Name:L"<UNKNOWN>");\r
+ }\r
+ if (Name != NULL) {\r
+ FreePool(Name);\r
+ }\r
+ }\r
+\r
+ if (HandleList != NULL) {\r
+ FreePool(HandleList);\r
+ }\r
+ \r
+ }\r
+ SHELL_FREE_NON_NULL(Language);\r
+ ShellCommandLineFreeVarList (Package);\r
+ }\r
+ return (ShellStatus);\r
+}\r
+\r
--- /dev/null
+/** @file\r
+ Main file for Dh shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-p", TypeValue},\r
+ {L"-d", TypeFlag},\r
+ {L"-v", TypeFlag},\r
+ {L"-verbose", TypeFlag},\r
+ {L"-sfo", TypeFlag},\r
+ {L"-l", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {\r
+ &gEfiDriverBindingProtocolGuid,\r
+ &gEfiPlatformDriverOverrideProtocolGuid,\r
+ &gEfiBusSpecificDriverOverrideProtocolGuid,\r
+ &gEfiDriverDiagnosticsProtocolGuid,\r
+ &gEfiDriverDiagnostics2ProtocolGuid,\r
+ &gEfiComponentNameProtocolGuid,\r
+ &gEfiComponentName2ProtocolGuid,\r
+ &gEfiPlatformToDriverConfigurationProtocolGuid,\r
+ &gEfiDriverSupportedEfiVersionProtocolGuid,\r
+ &gEfiDriverFamilyOverrideProtocolGuid,\r
+ &gEfiDriverHealthProtocolGuid,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ NULL\r
+};\r
+\r
+BOOLEAN\r
+EFIAPI\r
+IsDriverProt (\r
+ IN CONST EFI_GUID *Guid\r
+ )\r
+{\r
+ CONST EFI_GUID **GuidWalker;\r
+ BOOLEAN GuidFound;\r
+ GuidFound = FALSE;\r
+ for (GuidWalker = UefiDriverModelProtocolsGuidArray\r
+ ; GuidWalker != NULL && *GuidWalker != NULL\r
+ ; GuidWalker++\r
+ ){\r
+ if (CompareGuid(*GuidWalker, Guid)) {\r
+ GuidFound = TRUE;\r
+ break;\r
+ }\r
+ }\r
+ return (GuidFound);\r
+}\r
+\r
+CHAR16*\r
+EFIAPI\r
+GetProtocolInfoString(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST CHAR8 *Language,\r
+ IN CONST CHAR16 *Seperator,\r
+ IN CONST BOOLEAN DriverInfo,\r
+ IN CONST BOOLEAN Verbose,\r
+ IN CONST BOOLEAN ExtraInfo\r
+ )\r
+{\r
+ EFI_GUID **ProtocolGuidArray;\r
+ UINTN ArrayCount;\r
+ UINTN ProtocolIndex;\r
+ EFI_STATUS Status;\r
+ CHAR16 *RetVal;\r
+ UINTN Size;\r
+ CHAR16 *Temp;\r
+\r
+ ProtocolGuidArray = NULL;\r
+\r
+ Status = gBS->ProtocolsPerHandle (\r
+ TheHandle,\r
+ &ProtocolGuidArray,\r
+ &ArrayCount\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ RetVal = NULL;\r
+ Size = 0;\r
+ for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
+ Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);\r
+ if (Temp != NULL) {\r
+ ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
+ if (Size != 0) {\r
+ StrnCatGrow(&RetVal, &Size, Seperator, 0);\r
+ }\r
+ StrnCatGrow(&RetVal, &Size, L"%H", 0);\r
+ StrnCatGrow(&RetVal, &Size, Temp, 0);\r
+ StrnCatGrow(&RetVal, &Size, L"%N", 0);\r
+ FreePool(Temp);\r
+ }\r
+ if (ExtraInfo) {\r
+ Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);\r
+ if (Temp != NULL) {\r
+ ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
+ if (!Verbose) {\r
+ StrnCatGrow(&RetVal, &Size, L"(", 0);\r
+ StrnCatGrow(&RetVal, &Size, Temp, 0);\r
+ StrnCatGrow(&RetVal, &Size, L")", 0);\r
+ } else {\r
+ StrnCatGrow(&RetVal, &Size, Seperator, 0);\r
+ StrnCatGrow(&RetVal, &Size, Temp, 0);\r
+ }\r
+ FreePool(Temp);\r
+ }\r
+ }\r
+ }\r
+ } else {\r
+ return (NULL);\r
+ }\r
+\r
+ if (ProtocolGuidArray != NULL) {\r
+ FreePool(ProtocolGuidArray);\r
+ }\r
+ ASSERT((RetVal == NULL && Size == 0) || (RetVal != NULL));\r
+ StrnCatGrow(&RetVal, &Size, Seperator, 0);\r
+ return (RetVal);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+DoDhByHandle(\r
+ IN CONST EFI_HANDLE TheHandle,\r
+ IN CONST BOOLEAN Verbose,\r
+ IN CONST BOOLEAN Sfo,\r
+ IN CONST CHAR8 *Language,\r
+ IN CONST BOOLEAN DriverInfo,\r
+ IN CONST BOOLEAN Multiple\r
+ )\r
+{\r
+ CHAR16 *ProtocolInfoString;\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_STATUS Status;\r
+\r
+ Status = EFI_SUCCESS;\r
+ ShellStatus = SHELL_SUCCESS;\r
+ ProtocolInfoString = NULL;\r
+\r
+ if (!Sfo) {\r
+ if (Multiple) {\r
+ ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", DriverInfo, Verbose, TRUE);\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN (STR_DH_OUTPUT),\r
+ gShellDriver1HiiHandle,\r
+ ConvertHandleToHandleIndex(TheHandle),\r
+ ProtocolInfoString==NULL?L"":ProtocolInfoString);\r
+ } else {\r
+ ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", DriverInfo, Verbose, TRUE);\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN (STR_DH_OUTPUT_SINGLE),\r
+ gShellDriver1HiiHandle,\r
+ ConvertHandleToHandleIndex(TheHandle),\r
+ TheHandle,\r
+ ProtocolInfoString==NULL?L"":ProtocolInfoString);\r
+ }\r
+ } else {\r
+//#string STR_DH_OUTPUT_SFO #language en-US "%s, %s, %s, %H%02x%N, %s, %s\r\n"\r
+ ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", DriverInfo, FALSE, FALSE);\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN (STR_DH_OUTPUT_SFO),\r
+ gShellDriver1HiiHandle,\r
+ Multiple ?L"HandlesInfo":L"HandleInfo",\r
+ L"DriverName",\r
+ L"ControllerName",\r
+ ConvertHandleToHandleIndex(TheHandle),\r
+ L"DevPath",\r
+ ProtocolInfoString==NULL?L"":ProtocolInfoString);\r
+\r
+\r
+ }\r
+\r
+\r
+ if (ProtocolInfoString != NULL) {\r
+ FreePool(ProtocolInfoString);\r
+ }\r
+ return (ShellStatus);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+DoDhForHandleList(\r
+ IN CONST EFI_HANDLE *HandleList,\r
+ IN CONST BOOLEAN Sfo,\r
+ IN CONST CHAR8 *Language,\r
+ IN CONST BOOLEAN DriverInfo\r
+ )\r
+{\r
+ CONST EFI_HANDLE *HandleWalker;\r
+ SHELL_STATUS ShellStatus;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+\r
+ for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {\r
+ ShellStatus = DoDhByHandle(\r
+ *HandleWalker,\r
+ FALSE,\r
+ Sfo,\r
+ Language,\r
+ DriverInfo,\r
+ TRUE\r
+ );\r
+ }\r
+ return (ShellStatus);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+DoDhForAll(\r
+ IN CONST BOOLEAN Sfo,\r
+ IN CONST CHAR8 *Language,\r
+ IN CONST BOOLEAN DriverInfo\r
+ )\r
+{\r
+ EFI_HANDLE *HandleList;\r
+ SHELL_STATUS ShellStatus;\r
+\r
+ HandleList = GetHandleListByProtocol(NULL);\r
+\r
+ ShellStatus = DoDhForHandleList(\r
+ HandleList,\r
+ Sfo,\r
+ Language,\r
+ DriverInfo);\r
+\r
+ FreePool(HandleList);\r
+\r
+ return (ShellStatus);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+DoDhByProtocol(\r
+ IN CONST CHAR16 *ProtocolName,\r
+ IN CONST BOOLEAN Sfo,\r
+ IN CONST CHAR8 *Language,\r
+ IN CONST BOOLEAN DriverInfo\r
+ )\r
+{\r
+ EFI_GUID *Guid;\r
+ EFI_STATUS Status;\r
+ EFI_HANDLE *HandleList;\r
+ SHELL_STATUS ShellStatus;\r
+\r
+ ASSERT(ProtocolName != NULL);\r
+\r
+ Status = GetGuidFromStringName(ProtocolName, Language, &Guid);\r
+ if (EFI_ERROR(Status)) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ HandleList = GetHandleListByProtocol(Guid);\r
+\r
+ ShellStatus = DoDhForHandleList(\r
+ HandleList,\r
+ Sfo,\r
+ Language,\r
+ DriverInfo);\r
+\r
+ SHELL_FREE_NON_NULL(HandleList);\r
+\r
+ return (ShellStatus);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDh (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CHAR8 *Language;\r
+ CONST CHAR16 *Lang;\r
+ CONST CHAR16 *Temp2;\r
+ BOOLEAN SfoMode;\r
+ BOOLEAN FlagD;\r
+ BOOLEAN Verbose;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ Language = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 2) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ Language = AllocateZeroPool(10);\r
+ AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");\r
+ FlagD = ShellCommandLineGetFlag(Package, L"-d");\r
+ if (ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose")) {\r
+ Verbose = TRUE;\r
+ } else {\r
+ Verbose = FALSE;\r
+ }\r
+\r
+ if (ShellCommandLineGetFlag(Package, L"-p")) {\r
+ if (ShellCommandLineGetCount(Package) > 1) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ //\r
+ // print by protocol\r
+ //\r
+ ShellStatus = DoDhByProtocol(\r
+ ShellCommandLineGetValue(Package, L"-p"),\r
+ SfoMode,\r
+ Lang==NULL?NULL:Language,\r
+ FlagD\r
+ );\r
+ }\r
+ } else {\r
+ Temp2 = ShellCommandLineGetRawValue(Package, 1);\r
+ if (Temp2 == NULL) {\r
+ //\r
+ // Print everything\r
+ //\r
+ ShellStatus = DoDhForAll(\r
+ SfoMode,\r
+ Lang==NULL?NULL:Language,\r
+ FlagD\r
+ );\r
+ } else {\r
+ if (!ShellIsHexOrDecimalNumber(Temp2, TRUE, FALSE) || ConvertHandleIndexToHandle(StrHexToUintn(Temp2)) == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ //\r
+ // print 1 handle\r
+ //\r
+ ShellStatus = DoDhByHandle(\r
+ ConvertHandleIndexToHandle(StrHexToUintn(Temp2)),\r
+ Verbose,\r
+ SfoMode,\r
+ Lang==NULL?NULL:Language,\r
+ FlagD,\r
+ FALSE\r
+ );\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ ShellCommandLineFreeVarList (Package);\r
+ SHELL_FREE_NON_NULL(Language);\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for Disconnect shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-r", TypeFlag},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+DisconnectAll(\r
+ VOID\r
+ )\r
+{\r
+ //\r
+ // Stolen from UEFI 2.3 spec (May 2009 version)\r
+ // Pages 171/172\r
+ // Removed gBS local definition\r
+ //\r
+\r
+ //\r
+ // Disconnect All Handles Example\r
+ // The following example recusively disconnects all drivers from all\r
+ // controllers in a platform.\r
+ //\r
+ EFI_STATUS Status;\r
+// EFI_BOOT_SERVICES *gBS;\r
+ UINTN HandleCount;\r
+ EFI_HANDLE *HandleBuffer;\r
+ UINTN HandleIndex;\r
+ //\r
+ // Retrieve the list of all handles from the handle database\r
+ //\r
+ Status = gBS->LocateHandleBuffer (\r
+ AllHandles,\r
+ NULL,\r
+ NULL,\r
+ &HandleCount,\r
+ &HandleBuffer\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {\r
+ Status = gBS->DisconnectController (\r
+ HandleBuffer[HandleIndex],\r
+ NULL,\r
+ NULL\r
+ );\r
+ }\r
+ gBS->FreePool(HandleBuffer);\r
+ //\r
+ // end of stealing\r
+ //\r
+ }\r
+ return (EFI_SUCCESS);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDisconnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CONST CHAR16 *Param1;\r
+ CONST CHAR16 *Param2;\r
+ CONST CHAR16 *Param3;\r
+ EFI_HANDLE Handle1;\r
+ EFI_HANDLE Handle2;\r
+ EFI_HANDLE Handle3;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetFlag(Package, L"-r")){\r
+ if (ShellCommandLineGetCount(Package) > 1){\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetCount(Package) < 1) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ Status = DisconnectAll();\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 4){\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetCount(Package) < 2) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ //\r
+ // must have between 1 and 3 handles passed in ...\r
+ //\r
+ Param1 = ShellCommandLineGetRawValue(Package, 1);\r
+ Param2 = ShellCommandLineGetRawValue(Package, 2);\r
+ Param3 = ShellCommandLineGetRawValue(Package, 3);\r
+ Handle1 = Param1!=NULL?ConvertHandleIndexToHandle(StrHexToUintn(Param1)):NULL;\r
+ Handle2 = Param2!=NULL?ConvertHandleIndexToHandle(StrHexToUintn(Param2)):NULL;\r
+ Handle3 = Param3!=NULL?ConvertHandleIndexToHandle(StrHexToUintn(Param3)):NULL;\r
+\r
+ if (Param1 != NULL && Handle1 == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param1);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (Param2 != NULL && Handle2 == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param2);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (Param3 != NULL && Handle3 == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param3);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (EFI_ERROR(gBS->OpenProtocol(Handle1, &gEfiDevicePathProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ ASSERT(Param1 != NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_NOT), gShellDriver1HiiHandle, StrHexToUintn(Param1), L"controller handle");\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (Handle2 != NULL && EFI_ERROR(gBS->OpenProtocol(Handle2, &gEfiDriverBindingProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ ASSERT(Param2 != NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_NOT), gShellDriver1HiiHandle, StrHexToUintn(Param2), L"driver handle");\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(Param1 != NULL);\r
+ ASSERT(Param2 != NULL);\r
+ ASSERT(Param3 != NULL);\r
+ Status = gBS->DisconnectController(Handle1, Handle2, Handle3);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_3P_RESULT), gShellDriver1HiiHandle, L"Disconnect", Handle1, Handle2, Handle3, Status);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ if (ShellStatus == SHELL_SUCCESS) {\r
+ if (Status == EFI_SECURITY_VIOLATION) {\r
+ ShellStatus = SHELL_SECURITY_VIOLATION;\r
+ } else if (Status == EFI_INVALID_PARAMETER) {\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (EFI_ERROR(Status)) {\r
+ ShellStatus = SHELL_NOT_FOUND;\r
+ }\r
+ }\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for Drivers shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-sfo", TypeFlag},\r
+ {L"-l", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+CHAR16*\r
+EFIAPI\r
+GetDevicePathTextForHandle(\r
+ IN EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
+ EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;\r
+ EFI_DEVICE_PATH_PROTOCOL *FinalPath;\r
+ CHAR16 *RetVal;\r
+\r
+ FinalPath = NULL;\r
+\r
+ Status = gBS->OpenProtocol (\r
+ TheHandle,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ (VOID**)&LoadedImage,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ Status = gBS->OpenProtocol (\r
+ LoadedImage->DeviceHandle,\r
+ &gEfiDevicePathProtocolGuid,\r
+ (VOID**)&ImageDevicePath,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ FinalPath = AppendDevicePath (ImageDevicePath, LoadedImage->FilePath);\r
+ gBS->CloseProtocol(\r
+ LoadedImage->DeviceHandle,\r
+ &gEfiDevicePathProtocolGuid,\r
+ gImageHandle,\r
+ NULL);\r
+ }\r
+ gBS->CloseProtocol(\r
+ TheHandle,\r
+ &gEfiLoadedImageProtocolGuid,\r
+ gImageHandle,\r
+ NULL);\r
+ }\r
+\r
+ if (FinalPath == NULL) {\r
+ return (NULL);\r
+ }\r
+ RetVal = gEfiShellProtocol->GetFilePathFromDevicePath(FinalPath);\r
+ if (RetVal == NULL) {\r
+ RetVal = gDevPathToText->ConvertDevicePathToText(FinalPath, TRUE, TRUE);\r
+ }\r
+ FreePool(FinalPath);\r
+ return (RetVal);\r
+}\r
+\r
+BOOLEAN\r
+EFIAPI\r
+ReturnDriverConfig(\r
+ IN CONST EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverConfigurationProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);\r
+ if (EFI_ERROR(Status)) {\r
+ return (FALSE);\r
+ }\r
+ return (TRUE);\r
+}\r
+\r
+BOOLEAN\r
+EFIAPI\r
+ReturnDriverDiag(\r
+ IN CONST EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);\r
+ if (EFI_ERROR(Status)) {\r
+ Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverDiagnosticsProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);\r
+ if (EFI_ERROR(Status)) {\r
+ return (FALSE);\r
+ }\r
+ }\r
+ return (TRUE);\r
+}\r
+\r
+UINT32\r
+EFIAPI\r
+ReturnDriverVersion(\r
+ IN CONST EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;\r
+ EFI_STATUS Status;\r
+ UINT32 RetVal;\r
+\r
+ RetVal = (UINT32)-1;\r
+\r
+ Status = gBS->OpenProtocol((EFI_HANDLE)TheHandle, &gEfiDriverBindingProtocolGuid, (VOID**)&DriverBinding, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+ if (!EFI_ERROR(Status)) {\r
+ RetVal = DriverBinding->Version;\r
+ gBS->CloseProtocol(TheHandle, &gEfiDriverBindingProtocolGuid, gImageHandle, NULL);\r
+ }\r
+ return (RetVal);\r
+}\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrivers (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CHAR8 *Language;\r
+ CONST CHAR16 *Lang;\r
+ EFI_HANDLE *HandleList;\r
+ EFI_HANDLE *HandleWalker;\r
+ UINTN ChildCount;\r
+ UINTN DeviceCount;\r
+ CHAR16 *Temp2;\r
+ CHAR16 *FormatString;\r
+ UINT32 DriverVersion;\r
+ BOOLEAN DriverConfig;\r
+ BOOLEAN DriverDiag;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ Language = NULL;\r
+ FormatString = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 1) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ ASSERT(Language == NULL);\r
+ // Language = AllocateZeroPool(10);\r
+ // AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ if (ShellCommandLineGetFlag(Package, L"-sfo")) {\r
+ FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE_SFO), Language);\r
+ } else {\r
+ FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE), Language);\r
+ //\r
+ // print the header row\r
+ //\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ Language,\r
+ STRING_TOKEN(STR_DRIVERS_HEADER_LINES),\r
+ gShellDriver1HiiHandle);\r
+ }\r
+\r
+ HandleList = GetHandleListByProtocol(&gEfiDriverBindingProtocolGuid);\r
+ for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL ; HandleWalker++){\r
+ ChildCount = 0;\r
+ DeviceCount = 0;\r
+ Status = ParseHandleDatabaseForChildDevices (*HandleWalker, &ChildCount , NULL);\r
+ Status = PARSE_HANDLE_DATABASE_DEVICES (*HandleWalker, &DeviceCount, NULL);\r
+ Temp2 = GetDevicePathTextForHandle(*HandleWalker);\r
+ DriverVersion = ReturnDriverVersion(*HandleWalker);\r
+ DriverConfig = ReturnDriverConfig(*HandleWalker);\r
+ DriverDiag = ReturnDriverDiag (*HandleWalker);\r
+ Lang = GetStringNameFromHandle(*HandleWalker, Language==NULL?"en":Language);\r
+\r
+ ShellPrintEx(\r
+ -1,\r
+ -1,\r
+ FormatString,\r
+ ConvertHandleToHandleIndex(*HandleWalker),\r
+ DriverVersion,\r
+ ChildCount > 0?L'B':(DeviceCount > 0?L'D':L'?'),\r
+ DriverConfig?L'Y':L'N',\r
+ DriverDiag?L'Y':L'N',\r
+ DeviceCount,\r
+ ChildCount,\r
+ Lang,\r
+ Temp2==NULL?L"":Temp2\r
+ );\r
+ if (Temp2 != NULL) {\r
+ FreePool(Temp2);\r
+ }\r
+ }\r
+ }\r
+ SHELL_FREE_NON_NULL(Language);\r
+ ShellCommandLineFreeVarList (Package);\r
+ SHELL_FREE_NON_NULL(FormatString);\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for DrvCfg shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+#include <Protocol/HiiConfigAccess.h>\r
+#include <Protocol/HiiDatabase.h>\r
+\r
+/**\r
+ Function to validate configuration information on a configurable handle.\r
+\r
+ @param[in] Handle The handle to validate info on.\r
+ @param[in] HiiDb A pointer to the HII Database protocol.\r
+\r
+ @retval EFI_SUCCESS The operation was successful.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ValidateConfigInfoOnSingleHandleHii(\r
+ IN CONST EFI_HANDLE Handle,\r
+ IN EFI_HII_DATABASE_PROTOCOL *HiiDb\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN Size;\r
+ EFI_HII_HANDLE *HiiHandle;\r
+ EFI_HII_HANDLE *CurrentHandle;\r
+ EFI_HANDLE NormalHandle;\r
+\r
+ if (HiiDb == NULL || Handle == NULL) {\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ Size = 0;\r
+ HiiHandle = NULL;\r
+\r
+ Status = HiiDb->ListPackageLists(\r
+ HiiDb,\r
+ EFI_HII_PACKAGE_TYPE_ALL,\r
+ NULL,\r
+ &Size,\r
+ HiiHandle);\r
+\r
+ if (Status == EFI_BUFFER_TOO_SMALL) {\r
+ HiiHandle = AllocateZeroPool(Size);\r
+ if (HiiHandle == NULL) {\r
+ return (EFI_OUT_OF_RESOURCES);\r
+ }\r
+ Status = HiiDb->ListPackageLists(\r
+ HiiDb,\r
+ EFI_HII_PACKAGE_TYPE_ALL,\r
+ NULL,\r
+ &Size,\r
+ HiiHandle);\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ SHELL_FREE_NON_NULL(HiiHandle);\r
+ return (Status);\r
+ }\r
+\r
+ for (CurrentHandle = HiiHandle ; CurrentHandle != NULL && *CurrentHandle != NULL ; CurrentHandle++) {\r
+ NormalHandle = NULL;\r
+ Status = HiiDb->GetPackageListHandle(\r
+ HiiDb,\r
+ *CurrentHandle,\r
+ &NormalHandle);\r
+ if (NormalHandle == Handle) {\r
+ break;\r
+ }\r
+ }\r
+\r
+\r
+\r
+\r
+\r
+ SHELL_FREE_NON_NULL(HiiHandle);\r
+ return (Status);\r
+}\r
+\r
+/**\r
+ Function to validate configuration information on all configurable handles.\r
+\r
+ @param[in] ChildrenToo TRUE to tewst for children.\r
+\r
+ @retval SHELL_SUCCESS The operation was successful.\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ValidOptionsOnAll(\r
+ IN CONST BOOLEAN ChildrenToo\r
+ )\r
+{\r
+ EFI_HANDLE *HandleList;\r
+ EFI_HANDLE *CurrentHandle;\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_STATUS Status;\r
+ BOOLEAN Found;\r
+ EFI_HII_DATABASE_PROTOCOL *HiiDb;\r
+\r
+ Found = FALSE;\r
+ HandleList = NULL;\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+\r
+ Status = gBS->LocateProtocol(&gEfiHiiDatabaseProtocolGuid, NULL, (VOID**)&HiiDb);\r
+ if (EFI_ERROR(Status)) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROTOCOL_NF), gShellDriver1HiiHandle, L"gEfiHiiDatabaseProtocolGuid", &gEfiHiiDatabaseProtocolGuid);\r
+ return (Status);\r
+ }\r
+\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_HEADER), gShellDriver1HiiHandle);\r
+\r
+ //\r
+ // First do HII method\r
+ //\r
+ HandleList = GetHandleListByProtocol(&gEfiHiiConfigAccessProtocolGuid);\r
+ for (CurrentHandle = HandleList ; CurrentHandle != NULL && *CurrentHandle != NULL && ShellStatus == SHELL_SUCCESS; CurrentHandle++){\r
+ Found = TRUE;\r
+ ///@todo VALIDATE\r
+ }\r
+ SHELL_FREE_NON_NULL(HandleList);\r
+\r
+ //\r
+ // Now do EFI 1.10 & UEFI 2.0 drivers\r
+ //\r
+ HandleList = GetHandleListByProtocol(&gEfiDriverConfigurationProtocolGuid);\r
+ for (CurrentHandle = HandleList ; CurrentHandle != NULL && *CurrentHandle != NULL && ShellStatus == SHELL_SUCCESS; CurrentHandle++){\r
+ Found = TRUE;\r
+ ///@todo VALIDATE\r
+ }\r
+\r
+ if (!Found) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);\r
+ return (SHELL_SUCCESS);\r
+ }\r
+\r
+ SHELL_FREE_NON_NULL(HandleList);\r
+ return (ShellStatus);\r
+}\r
+\r
+/**\r
+ Function to print out configuration information on a configurable handle.\r
+\r
+ @param[in] DriverHandle The driver handle to print info on.\r
+ @param[in] ControllerHandle The controllerHandle to print on.\r
+ @param[in] ChildrenToo TRUE to tewst for children.\r
+ @param[in] ProtocolMask BIT0 for HII, BIT1 for DirverConfiguration.\r
+\r
+ @retval SHELL_SUCCESS The operation was successful.\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+PrintConfigInfoOnSingleHandle(\r
+ IN CONST EFI_HANDLE DriverHandle,\r
+ IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
+ IN CONST BOOLEAN ChildrenToo,\r
+ IN CONST UINT8 ProtocolMask // BIT0 - HII, BIT1 - DriverConfiguration\r
+ )\r
+{\r
+ UINTN Index1;\r
+ UINTN Index2;\r
+ EFI_HANDLE *ChildHandleList;\r
+ UINTN Count;\r
+ UINTN LoopVar;\r
+\r
+ Index1 = DriverHandle == NULL ? 0 : ConvertHandleToHandleIndex(DriverHandle );\r
+ Index2 = ControllerHandle == NULL ? 0 : ConvertHandleToHandleIndex(ControllerHandle);\r
+\r
+ if ((ProtocolMask & BIT0) == BIT0) {\r
+ ASSERT(Index1 == 0);\r
+ ShellPrintHiiEx(\r
+ -1, \r
+ -1, \r
+ NULL, \r
+ STRING_TOKEN (STR_DRVCFG_LINE_HII), \r
+ gShellDriver1HiiHandle, \r
+ Index2\r
+ );\r
+ }\r
+ if ((ProtocolMask & BIT1) == BIT1) {\r
+ PARSE_HANDLE_DATABASE_MANAGED_CHILDREN(DriverHandle, ControllerHandle, &Count, &ChildHandleList);\r
+ for (LoopVar = 0 ; LoopVar <= Count ; LoopVar++) {\r
+ ShellPrintHiiEx(\r
+ -1, \r
+ -1, \r
+ NULL, \r
+ STRING_TOKEN (STR_DRVCFG_LINE_DRV), \r
+ gShellDriver1HiiHandle, \r
+ Index1,\r
+ Index2,\r
+ Count != 0 ? ChildHandleList[LoopVar] : 0\r
+ );\r
+ }\r
+ }\r
+ return (SHELL_SUCCESS);\r
+}\r
+\r
+/**\r
+ Function to print out configuration information on all configurable handles.\r
+\r
+ @param[in] ChildrenToo TRUE to tewst for children.\r
+\r
+ @retval SHELL_SUCCESS The operation was successful.\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+PrintConfigInfoOnAll(\r
+ IN CONST BOOLEAN ChildrenToo\r
+ )\r
+{\r
+// lcoate all the HII_CONFIG_ACCESS_PROTOCOL - those are all configurable\r
+// then cross reference with EFI_DRIVER_CONFIGURATION_PROTOCOL - those are legacy configurable\r
+// can be on chlid, but that is ok... just find the driver\r
+ EFI_HANDLE *HandleList;\r
+ EFI_HANDLE *CurrentHandle;\r
+ EFI_HANDLE *DriverHandleList;\r
+ EFI_HANDLE *ParentHandleList;\r
+ EFI_HANDLE *CurrentDriver;\r
+ UINTN Count;\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_STATUS Status;\r
+ UINTN LoopVar;\r
+ BOOLEAN Found;\r
+\r
+ Found = FALSE;\r
+ Count = 0;\r
+ HandleList = NULL;\r
+ CurrentHandle = NULL;\r
+ DriverHandleList = NULL;\r
+ CurrentDriver = NULL;\r
+ ShellStatus = SHELL_SUCCESS;\r
+\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_HEADER), gShellDriver1HiiHandle);\r
+ //\r
+ // First do HII method\r
+ //\r
+ HandleList = GetHandleListByProtocol(&gEfiHiiConfigAccessProtocolGuid);\r
+ for (CurrentHandle = HandleList ; CurrentHandle != NULL && *CurrentHandle != NULL && ShellStatus == SHELL_SUCCESS; CurrentHandle++){\r
+ // is this a driver handle itself? if yes print options for it.\r
+ if (!EFI_ERROR(gBS->OpenProtocol(*CurrentHandle, &gEfiDriverBindingProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {\r
+ ShellStatus = PrintConfigInfoOnSingleHandle(*CurrentHandle, NULL, ChildrenToo, BIT0);\r
+ } else {\r
+ // get its driver and print options for it.\r
+ Count = 0;\r
+ Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS(*CurrentHandle, &Count, &DriverHandleList);\r
+ if (EFI_ERROR(Status)) {\r
+ Status = PARSE_HANDLE_DATABASE_PARENTS(*CurrentHandle, &Count, &ParentHandleList);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS(*ParentHandleList, &Count, &DriverHandleList);\r
+ }\r
+ }\r
+ if (Count == 0) {\r
+ Found = TRUE;\r
+ ShellStatus = PrintConfigInfoOnSingleHandle(NULL, *CurrentHandle, ChildrenToo, BIT0);\r
+ } else if (DriverHandleList != NULL) {\r
+ for (LoopVar = 0 ; LoopVar < Count ; LoopVar++) {\r
+ Found = TRUE;\r
+ ShellStatus = PrintConfigInfoOnSingleHandle(DriverHandleList[LoopVar], *CurrentHandle, ChildrenToo, BIT0);\r
+ }\r
+ }\r
+ SHELL_FREE_NON_NULL(DriverHandleList);\r
+ }\r
+ }\r
+ SHELL_FREE_NON_NULL(HandleList);\r
+\r
+ //\r
+ // Now do EFI 1.10 & UEFI 2.0 drivers\r
+ //\r
+ HandleList = GetHandleListByProtocol(&gEfiDriverConfigurationProtocolGuid);\r
+ for (CurrentHandle = HandleList ; CurrentHandle != NULL && *CurrentHandle != NULL && ShellStatus == SHELL_SUCCESS; CurrentHandle++){\r
+ Found = TRUE;\r
+ ShellStatus = PrintConfigInfoOnSingleHandle(*CurrentHandle, NULL, ChildrenToo, BIT1);\r
+ }\r
+ SHELL_FREE_NON_NULL(HandleList);\r
+ if (!Found) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);\r
+ return (SHELL_SUCCESS);\r
+ }\r
+ return (ShellStatus);\r
+}\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-c", TypeFlag},\r
+ {L"-s", TypeFlag},\r
+ {L"-v", TypeFlag},\r
+ {L"-l", TypeValue},\r
+ {L"-f", TypeValue},\r
+ {L"-o", TypeValue},\r
+ {L"-i", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrvCfg (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ CHAR8 *Language;\r
+ CONST CHAR16 *Lang;\r
+ CONST CHAR16 *Temp2;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ Language = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ Language = AllocateZeroPool(10);\r
+ AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ //\r
+ // Should be DriverHandle\r
+ //\r
+ Temp2 = ShellCommandLineGetRawValue(Package, 1);\r
+ if (Temp2 == NULL) {\r
+ //\r
+ // no driver specified. cannot be export, inport, or set (and no specified language)\r
+ //\r
+ if (ShellCommandLineGetFlag(Package, L"-s")\r
+ ||ShellCommandLineGetFlag(Package, L"-l")\r
+ ||ShellCommandLineGetFlag(Package, L"-o")\r
+ ||ShellCommandLineGetFlag(Package, L"-i")) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_REQ), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ //\r
+ // do a loop for validation, forcing, or printing\r
+ //\r
+ if (ShellCommandLineGetFlag(Package, L"-v") && ShellCommandLineGetFlag(Package, L"-f")) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONF), gShellDriver1HiiHandle, L"-v", L"-f");\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetFlag(Package, L"-v")){\r
+ //\r
+ // validate\r
+ //\r
+ ShellStatus = ValidOptionsOnAll(ShellCommandLineGetFlag(Package, L"-c"));\r
+ } else if (ShellCommandLineGetFlag(Package, L"-f")){\r
+ //\r
+ // force\r
+ //\r
+ASSERT(FALSE);// ShellStatus = ForceOptionsOnAll(ShellCommandLineGetFlag(Package, L"-c"));\r
+ } else {\r
+ //\r
+ // display all that are configurable\r
+ //\r
+ ShellStatus = PrintConfigInfoOnAll(ShellCommandLineGetFlag(Package, L"-c"));\r
+ }\r
+ }\r
+ } else {\r
+ //\r
+ // we have a driver handle, make sure it's valid then process it...\r
+ //\r
+ ASSERT(FALSE);\r
+ }\r
+ }\r
+ ShellCommandLineFreeVarList (Package);\r
+ SHELL_FREE_NON_NULL(Language);\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for DrvDiag shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST EFI_GUID *DiagGuidList[] = {&gEfiDriverDiagnosticsProtocolGuid, &gEfiDriverDiagnostics2ProtocolGuid, NULL};\r
+//\r
+// We need 1 more item on the list...\r
+//\r
+typedef enum {\r
+ TEST_MODE_STANDARD = EfiDriverDiagnosticTypeStandard,\r
+ TEST_MODE_EXTENDED = EfiDriverDiagnosticTypeExtended,\r
+ TEST_MODE_MANUFACTURING = EfiDriverDiagnosticTypeManufacturing,\r
+ TEST_MODE_LIST,\r
+ TEST_MODE_MAX\r
+} DRV_DIAG_TEST_MODE;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+DoDiagnostics (\r
+ IN CONST DRV_DIAG_TEST_MODE Mode,\r
+ IN CONST CHAR8 *Lang,\r
+ IN CONST BOOLEAN AllChilds,\r
+ IN CONST EFI_HANDLE DriverHandle,\r
+ IN CONST EFI_HANDLE ControllerHandle,\r
+ IN CONST EFI_HANDLE ChildHandle\r
+ )\r
+{\r
+ EFI_DRIVER_DIAGNOSTICS_PROTOCOL *DriverDiagnostics;\r
+ EFI_DRIVER_DIAGNOSTICS2_PROTOCOL *DriverDiagnostics2;\r
+ EFI_HANDLE *DriverHandleList;\r
+ EFI_HANDLE *ControllerHandleList;\r
+ EFI_HANDLE *ChildHandleList;\r
+ EFI_HANDLE *Walker;\r
+ UINTN DriverHandleListCount;\r
+ UINTN ControllerHandleListCount;\r
+ UINTN ChildHandleListCount;\r
+ UINTN DriverHandleListLoop;\r
+ UINTN ControllerHandleListLoop;\r
+ UINTN ChildHandleListLoop;\r
+ EFI_STATUS Status;\r
+ EFI_STATUS Status2;\r
+ EFI_GUID *ErrorType;\r
+ UINTN OutBufferSize;\r
+ CHAR16 *OutBuffer;\r
+ UINTN HandleIndex1;\r
+ UINTN HandleIndex2;\r
+\r
+ if ((ChildHandle != NULL && AllChilds) || (Mode >= TEST_MODE_MAX)){\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ if (Lang == NULL || AsciiStrLen(Lang) < 3) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"-l <value>");\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ DriverDiagnostics = NULL;\r
+ DriverDiagnostics2 = NULL;\r
+ Status = EFI_SUCCESS;\r
+ Status2 = EFI_SUCCESS;\r
+ DriverHandleList = NULL;\r
+ ControllerHandleList = NULL;\r
+ ChildHandleList = NULL;\r
+ OutBuffer = NULL;\r
+ ErrorType = NULL;\r
+ DriverHandleListCount = 0;\r
+ ControllerHandleListCount = 0;\r
+ ChildHandleListCount = 0;\r
+\r
+ if (DriverHandle != NULL) {\r
+ DriverHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));\r
+ ASSERT(DriverHandleList!=NULL);\r
+ DriverHandleList[0] = DriverHandle;\r
+ DriverHandleListCount = 1;\r
+ } else {\r
+ DriverHandleList = GetHandleListByProtocolList(DiagGuidList);\r
+ if (DriverHandleList == NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);\r
+ return (EFI_NOT_FOUND);\r
+ } \r
+ for (Walker = DriverHandleList ; Walker != NULL && *Walker != NULL ; DriverHandleListCount++, Walker++);\r
+ }\r
+\r
+ if (ControllerHandle != NULL) {\r
+ ControllerHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));\r
+ ASSERT(ControllerHandleList!=NULL);\r
+ ControllerHandleList[0] = ControllerHandle;\r
+ ControllerHandleListCount = 1;\r
+ } else {\r
+ ControllerHandleList = NULL;\r
+ }\r
+\r
+ if (ChildHandle != NULL) {\r
+ ChildHandleList = AllocateZeroPool(2*sizeof(EFI_HANDLE));\r
+ ASSERT(ChildHandleList!=NULL);\r
+ ChildHandleList[0] = ChildHandle;\r
+ ChildHandleListCount = 1;\r
+ } else if (AllChilds) {\r
+ ChildHandleList = NULL;\r
+ //\r
+ // This gets handled in the loop below.\r
+ //\r
+ } else {\r
+ ChildHandleList = NULL;\r
+ }\r
+\r
+ for (DriverHandleListLoop = 0\r
+ ; DriverHandleListLoop < DriverHandleListCount\r
+ ; DriverHandleListLoop++\r
+ ){\r
+ if (ControllerHandle == NULL) {\r
+ PARSE_HANDLE_DATABASE_DEVICES(DriverHandleList[DriverHandleListLoop], &ControllerHandleListCount, &ControllerHandleList);\r
+ }\r
+ for (ControllerHandleListLoop = 0\r
+ ; ControllerHandleListLoop < ControllerHandleListCount\r
+ ; ControllerHandleListLoop++\r
+ ){\r
+ if (AllChilds) {\r
+ ASSERT(ChildHandleList == NULL);\r
+ PARSE_HANDLE_DATABASE_MANAGED_CHILDREN(\r
+ DriverHandleList[DriverHandleListLoop], \r
+ ControllerHandleList[ControllerHandleListLoop],\r
+ &ChildHandleListCount,\r
+ &ChildHandleList);\r
+ }\r
+ for (ChildHandleListLoop = 0\r
+ ; (ChildHandleListLoop < ChildHandleListCount || ChildHandleList == NULL)\r
+ ; ChildHandleListLoop++\r
+ ){\r
+ if (Mode != TEST_MODE_LIST) {\r
+ if (Lang[2] == '-') {\r
+ //\r
+ // Get the protocol pointer and call the function\r
+ //\r
+ Status = gBS->OpenProtocol(\r
+ DriverHandleList[DriverHandleListLoop],\r
+ &gEfiDriverDiagnostics2ProtocolGuid,\r
+ (VOID**)&DriverDiagnostics2,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = DriverDiagnostics2->RunDiagnostics(\r
+ DriverDiagnostics2,\r
+ ControllerHandleList[ControllerHandleListLoop],\r
+ ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],\r
+ (EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,\r
+ (CHAR8*)Lang,\r
+ &ErrorType,\r
+ &OutBufferSize,\r
+ &OutBuffer);\r
+ }\r
+ } else {\r
+ Status = gBS->OpenProtocol(\r
+ DriverHandleList[DriverHandleListLoop],\r
+ &gEfiDriverDiagnosticsProtocolGuid,\r
+ (VOID**)&DriverDiagnostics,\r
+ gImageHandle,\r
+ NULL,\r
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+ if (!EFI_ERROR(Status)) {\r
+ Status = DriverDiagnostics->RunDiagnostics(\r
+ DriverDiagnostics,\r
+ ControllerHandleList[ControllerHandleListLoop],\r
+ ChildHandleList == NULL?NULL:ChildHandleList[ChildHandleListLoop],\r
+ (EFI_DRIVER_DIAGNOSTIC_TYPE)Mode,\r
+ (CHAR8*)Lang,\r
+ &ErrorType,\r
+ &OutBufferSize,\r
+ &OutBuffer);\r
+ }\r
+ }\r
+ if (EFI_ERROR(Status)) {\r
+ Status2 = Status;\r
+ }\r
+ HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);\r
+ HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN (STR_3P_RESULT),\r
+ gShellDriver1HiiHandle,\r
+ L"DrvDiag",\r
+ HandleIndex1,\r
+ HandleIndex2,\r
+ ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop]),\r
+ Status);\r
+ if (OutBuffer!=NULL) {\r
+ FreePool(OutBuffer);\r
+ OutBuffer = NULL;\r
+ }\r
+ if (ErrorType!=NULL) {\r
+ FreePool(ErrorType);\r
+ ErrorType = NULL;\r
+ }\r
+ } else {\r
+ HandleIndex1 = ConvertHandleToHandleIndex(DriverHandleList[DriverHandleListLoop]);\r
+ HandleIndex2 = ConvertHandleToHandleIndex(ControllerHandleList[ControllerHandleListLoop]);\r
+ //\r
+ // Print out the information that this set can be tested\r
+ //\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN (STR_DRV_DIAG_ITEM_LINE),\r
+ gShellDriver1HiiHandle,\r
+ HandleIndex1,\r
+ HandleIndex2,\r
+ ChildHandleList == NULL?0:ConvertHandleToHandleIndex(ChildHandleList[ChildHandleListLoop])\r
+ );\r
+ }\r
+\r
+ //\r
+ // If we are doing a single pass with NULL child jump out after a single loop\r
+ //\r
+ if (ChildHandleList == NULL) {\r
+ break;\r
+ }\r
+ }\r
+ if (AllChilds) {\r
+ SHELL_FREE_NON_NULL(ChildHandleList);\r
+ ChildHandleList = NULL;\r
+ ChildHandleListCount = 0;\r
+ }\r
+ }\r
+ if (ControllerHandle == NULL) {\r
+ SHELL_FREE_NON_NULL(ControllerHandleList);\r
+ ControllerHandleList = NULL;\r
+ ControllerHandleListCount = 0;\r
+ }\r
+ }\r
+\r
+ if (DriverHandleList != NULL) {\r
+ FreePool(DriverHandleList);\r
+ }\r
+ if (ControllerHandleList != NULL) {\r
+ FreePool(ControllerHandleList);\r
+ }\r
+ if (ChildHandleList != NULL) {\r
+ FreePool(ChildHandleList);\r
+ }\r
+ return (Status2);\r
+}\r
+\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-c", TypeFlag},\r
+ {L"-s", TypeFlag},\r
+ {L"-e", TypeFlag},\r
+ {L"-m", TypeFlag},\r
+ {L"-l", TypeValue},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrvDiag (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ DRV_DIAG_TEST_MODE Mode;\r
+ CHAR8 *Language;\r
+ CONST CHAR16 *DriverHandleStr;\r
+ CONST CHAR16 *ControllerHandleStr;\r
+ CONST CHAR16 *ChildHandleStr;\r
+ CONST CHAR16 *Lang;\r
+ EFI_HANDLE Handle1;\r
+ EFI_HANDLE Handle2;\r
+ EFI_HANDLE Handle3;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Mode = TEST_MODE_MAX;\r
+ Language = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ //\r
+ // if more than 3 'value' parameters (plus the name one) or we have any 2 mode flags\r
+ //\r
+ if ((ShellCommandLineGetCount(Package) > 4)\r
+ ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-e"))\r
+ ||(ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-m"))\r
+ ||(ShellCommandLineGetFlag(Package, L"-e") && ShellCommandLineGetFlag(Package, L"-m"))\r
+ ){\r
+ //\r
+ // error for too many parameters\r
+ //\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if ((ShellCommandLineGetFlag(Package, L"-s"))\r
+ || (ShellCommandLineGetFlag(Package, L"-e"))\r
+ || (ShellCommandLineGetFlag(Package, L"-m"))\r
+ ){\r
+ //\r
+ // Run the apropriate test\r
+ //\r
+ if (ShellCommandLineGetFlag(Package, L"-s")) {\r
+ Mode = TEST_MODE_STANDARD;\r
+ } else if (ShellCommandLineGetFlag(Package, L"-e")) {\r
+ Mode = TEST_MODE_EXTENDED;\r
+ } else if (ShellCommandLineGetFlag(Package, L"-m")) {\r
+ Mode = TEST_MODE_MANUFACTURING;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ //\r
+ // Do a listing of what's available to test\r
+ //\r
+ Mode = TEST_MODE_LIST;\r
+ }\r
+\r
+ Lang = ShellCommandLineGetValue(Package, L"-l");\r
+ if (Lang != NULL) {\r
+ Language = AllocateZeroPool(StrSize(Lang));\r
+ AsciiSPrint(Language, StrSize(Lang), "%S", Lang);\r
+ } else if (!ShellCommandLineGetFlag(Package, L"-l")){\r
+ Language = AllocateZeroPool(10);\r
+ AsciiSPrint(Language, 10, "en-us");\r
+ } else {\r
+ ASSERT(Language == NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");\r
+ ShellCommandLineFreeVarList (Package);\r
+ return (SHELL_INVALID_PARAMETER);\r
+ }\r
+\r
+ DriverHandleStr = ShellCommandLineGetRawValue(Package, 1);\r
+ ControllerHandleStr = ShellCommandLineGetRawValue(Package, 2);\r
+ ChildHandleStr = ShellCommandLineGetRawValue(Package, 3);\r
+\r
+ if (DriverHandleStr == NULL) {\r
+ Handle1 = NULL;\r
+ } else {\r
+ Handle1 = ConvertHandleIndexToHandle(StrHexToUintn(DriverHandleStr ));\r
+ }\r
+ if (ControllerHandleStr == NULL) {\r
+ Handle2 = NULL;\r
+ } else {\r
+ Handle2 = ConvertHandleIndexToHandle(StrHexToUintn(ControllerHandleStr));\r
+ }\r
+ if (ChildHandleStr == NULL) {\r
+ Handle3 = NULL;\r
+ } else {\r
+ Handle3 = ConvertHandleIndexToHandle(StrHexToUintn(ChildHandleStr ));\r
+ }\r
+\r
+ Status = DoDiagnostics (\r
+ Mode,\r
+ Language,\r
+ ShellCommandLineGetFlag(Package, L"-c"),\r
+ Handle1, \r
+ Handle2, \r
+ Handle3\r
+ );\r
+\r
+ SHELL_FREE_NON_NULL(Language);\r
+ ShellCommandLineFreeVarList (Package);\r
+\r
+ }\r
+ if (ShellStatus == SHELL_SUCCESS) {\r
+ if (Status == EFI_SECURITY_VIOLATION) {\r
+ ShellStatus = SHELL_SECURITY_VIOLATION;\r
+ } else if (Status == EFI_INVALID_PARAMETER) {\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (Status == EFI_NOT_FOUND) {\r
+ ShellStatus = SHELL_NOT_FOUND;\r
+ } else if (EFI_ERROR(Status)) {\r
+ ShellStatus = SHELL_NOT_FOUND;\r
+ }\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for OpenInfo shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST CHAR16 StringHandProt[] = L"HandProt ";\r
+STATIC CONST CHAR16 StringGetProt[] = L"GetProt ";\r
+STATIC CONST CHAR16 StringTestProt[] = L"TestProt ";\r
+STATIC CONST CHAR16 StringChild[] = L"Child ";\r
+STATIC CONST CHAR16 StringDriver[] = L"Driver ";\r
+STATIC CONST CHAR16 StringExclusive[] = L"Exclusive";\r
+STATIC CONST CHAR16 StringDriverEx[] = L"DriverEx ";\r
+STATIC CONST CHAR16 StringUnknown[] = L"Unknown ";\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+TraverseHandleDatabase (\r
+ IN CONST EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_GUID **ProtocolGuidArray;\r
+ UINTN ArrayCount;\r
+ UINTN ProtocolIndex;\r
+ EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;\r
+ UINTN OpenInfoCount;\r
+ UINTN OpenInfoIndex;\r
+ CONST CHAR16 *OpenTypeString;\r
+ CHAR16 *TempString;\r
+ UINTN HandleIndex;\r
+ CONST CHAR16 *Name;\r
+\r
+ ASSERT(TheHandle != NULL);\r
+\r
+ //\r
+ // Retrieve the list of all the protocols on the handle\r
+ //\r
+ Status = gBS->ProtocolsPerHandle (\r
+ TheHandle,\r
+ &ProtocolGuidArray,\r
+ &ArrayCount\r
+ );\r
+ ASSERT_EFI_ERROR(Status);\r
+ if (!EFI_ERROR (Status)) {\r
+\r
+ for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
+ //\r
+ // print out the human readable name for this one.\r
+ //\r
+ TempString = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], NULL);\r
+ if (TempString == NULL) {\r
+ continue;\r
+ }\r
+ ShellPrintEx(-1, -1, L"%H%s%N\r\n", TempString);\r
+ FreePool(TempString);\r
+\r
+ //\r
+ // Retrieve the list of agents that have opened each protocol\r
+ //\r
+ Status = gBS->OpenProtocolInformation (\r
+ TheHandle,\r
+ ProtocolGuidArray[ProtocolIndex],\r
+ &OpenInfo,\r
+ &OpenInfoCount\r
+ );\r
+ ASSERT_EFI_ERROR(Status);\r
+ if (!EFI_ERROR (Status)) {\r
+ for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
+ switch (OpenInfo[OpenInfoIndex].Attributes) {\r
+ case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: OpenTypeString = StringHandProt; break;\r
+ case EFI_OPEN_PROTOCOL_GET_PROTOCOL: OpenTypeString = StringGetProt; break;\r
+ case EFI_OPEN_PROTOCOL_TEST_PROTOCOL: OpenTypeString = StringTestProt; break;\r
+ case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER: OpenTypeString = StringChild; break;\r
+ case EFI_OPEN_PROTOCOL_BY_DRIVER: OpenTypeString = StringDriver; break;\r
+ case EFI_OPEN_PROTOCOL_EXCLUSIVE: OpenTypeString = StringExclusive; break;\r
+ case EFI_OPEN_PROTOCOL_BY_DRIVER|EFI_OPEN_PROTOCOL_EXCLUSIVE:\r
+ OpenTypeString = StringDriverEx; break;\r
+ default: OpenTypeString = StringUnknown; break;\r
+ }\r
+ HandleIndex = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].AgentHandle);\r
+ Name = GetStringNameFromHandle(OpenInfo[OpenInfoIndex].AgentHandle, "en");\r
+ if (OpenInfo[OpenInfoIndex].ControllerHandle!=NULL) {\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN(STR_OPENINFO_LINE),\r
+ gShellDriver1HiiHandle,\r
+ HandleIndex,\r
+ ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].ControllerHandle),\r
+ OpenInfo[OpenInfoIndex].OpenCount,\r
+ OpenTypeString,\r
+ Name\r
+ );\r
+ } else {\r
+ ShellPrintHiiEx(\r
+ -1,\r
+ -1,\r
+ NULL,\r
+ STRING_TOKEN(STR_OPENINFO_MIN_LINE),\r
+ gShellDriver1HiiHandle,\r
+ HandleIndex,\r
+ OpenInfo[OpenInfoIndex].OpenCount,\r
+ OpenTypeString,\r
+ Name\r
+ ); \r
+ }\r
+ }\r
+ FreePool (OpenInfo);\r
+ }\r
+ }\r
+ FreePool (ProtocolGuidArray);\r
+ }\r
+\r
+ return Status;\r
+}\r
+\r
+/**\r
+ Function for 'openinfo' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunOpenInfo (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_HANDLE TheHandle;\r
+ CONST CHAR16 *Param1;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ Status = CommandInit();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 2){\r
+ //\r
+ // error for too many parameters\r
+ //\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetCount(Package) == 0) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ Param1 = ShellCommandLineGetRawValue(Package, 1);\r
+ if (Param1 == NULL || ConvertHandleIndexToHandle(StrHexToUintn(Param1)) == NULL){\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param1);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ TheHandle = ConvertHandleIndexToHandle(StrHexToUintn(Param1));\r
+ ASSERT(TheHandle != NULL);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_OPENINFO_HEADER_LINE), gShellDriver1HiiHandle, StrHexToUintn(Param1), TheHandle);\r
+\r
+ Status = TraverseHandleDatabase (TheHandle);\r
+ if (!EFI_ERROR(Status)) {\r
+ } else {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param1);\r
+ ShellStatus = SHELL_NOT_FOUND;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for Reconnect shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunReconnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ SHELL_STATUS ShellStatus;\r
+\r
+ ShellStatus = ShellCommandRunDisconnect(ImageHandle, SystemTable);\r
+ if (ShellStatus == SHELL_SUCCESS) {\r
+ ShellStatus = ShellCommandRunConnect(ImageHandle, SystemTable);\r
+ }\r
+ return (ShellStatus);\r
+}\r
--- /dev/null
+/** @file\r
+ Main file for NULL named library for level 1 shell command functions.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\r
+\r
+STATIC CONST CHAR16 mFileName[] = L"Driver1Commands";\r
+EFI_HANDLE gShellDriver1HiiHandle = NULL;\r
+CONST EFI_GUID gShellDriver1HiiGuid = \\r
+ { \\r
+ 0xaf0b742, 0x63ec, 0x45bd, {0x8d, 0xb6, 0x71, 0xad, 0x7f, 0x2f, 0xe8, 0xe8} \\r
+ };\r
+\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellCommandGetManFileNameDriver1 (\r
+ VOID\r
+ )\r
+{\r
+ return (mFileName);\r
+}\r
+\r
+/**\r
+ Constructor for the Shell Driver1 Commands library.\r
+\r
+ @param ImageHandle the image handle of the process\r
+ @param SystemTable the EFI System Table pointer\r
+\r
+ @retval EFI_SUCCESS the shell command handlers were installed sucessfully\r
+ @retval EFI_UNSUPPORTED the shell level required was not found.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+UefiShellDriver1CommandsLibConstructor (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ //\r
+ // check our bit of the profiles mask\r
+ //\r
+ if ((PcdGet8(PcdShellProfileMask) & BIT0) == 0) {\r
+ return (EFI_UNSUPPORTED);\r
+ }\r
+\r
+ //\r
+ // install the HII stuff.\r
+ //\r
+ gShellDriver1HiiHandle = HiiAddPackages (&gShellDriver1HiiGuid, gImageHandle, UefiShellDriver1CommandsLibStrings, NULL);\r
+ if (gShellDriver1HiiHandle == NULL) {\r
+ return (EFI_DEVICE_ERROR);\r
+ }\r
+\r
+ //\r
+ // install our shell command handlers that are always installed\r
+ //\r
+ ShellCommandRegisterCommandName(L"connect", ShellCommandRunConnect , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_CONNECT) );\r
+ ShellCommandRegisterCommandName(L"devices", ShellCommandRunDevices , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DEVICES) );\r
+ ShellCommandRegisterCommandName(L"openinfo", ShellCommandRunOpenInfo , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_OPENINFO) );\r
+ ShellCommandRegisterCommandName(L"disconnect", ShellCommandRunDisconnect , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DISCONNECT));\r
+ ShellCommandRegisterCommandName(L"reconnect", ShellCommandRunReconnect , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_RECONNECT) );\r
+ ShellCommandRegisterCommandName(L"unload", ShellCommandRunUnload , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_UNLOAD) );\r
+ ShellCommandRegisterCommandName(L"drvdiag", ShellCommandRunDrvDiag , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DRVDIAG) );\r
+ ShellCommandRegisterCommandName(L"dh", ShellCommandRunDh , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DH) );\r
+ ShellCommandRegisterCommandName(L"drivers", ShellCommandRunDrivers , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DRIVERS) );\r
+ ShellCommandRegisterCommandName(L"devtree", ShellCommandRunDevTree , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DEVTREE) );\r
+ ShellCommandRegisterCommandName(L"drvcfg", ShellCommandRunDrvCfg , ShellCommandGetManFileNameDriver1, 0, L"Driver1", TRUE, gShellDriver1HiiHandle, STRING_TOKEN(STR_GET_HELP_DRVCFG) );\r
+\r
+ return (EFI_SUCCESS);\r
+}\r
+\r
+/**\r
+ Destructor for the library. free any resources.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+UefiShellDriver1CommandsLibDestructor (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ if (gShellDriver1HiiHandle != NULL) {\r
+ HiiRemovePackages(gShellDriver1HiiHandle);\r
+ }\r
+ return (EFI_SUCCESS);\r
+}\r
+\r
+\r
+\r
--- /dev/null
+/** @file\r
+ Main file for NULL named library for Profile1 shell command functions.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include <Uefi.h>\r
+#include <ShellBase.h>\r
+\r
+#include <Guid/GlobalVariable.h>\r
+#include <Guid/ConsoleInDevice.h>\r
+#include <Guid/ConsoleOutDevice.h>\r
+\r
+#include <Protocol/EfiShell.h>\r
+#include <Protocol/EfiShellParameters.h>\r
+#include <Protocol/DevicePath.h>\r
+#include <Protocol/LoadedImage.h>\r
+#include <Protocol/UnicodeCollation.h>\r
+#include <Protocol/DevicePathToText.h>\r
+#include <Protocol/DriverDiagnostics2.h>\r
+#include <Protocol/DriverDiagnostics.h>\r
+#include <Protocol/PlatformDriverOverride.h>\r
+#include <Protocol/BusSpecificDriverOverride.h>\r
+#include <Protocol/PlatformToDriverConfiguration.h>\r
+#include <Protocol/DriverSupportedEfiVersion.h>\r
+#include <Protocol/DriverFamilyOverride.h>\r
+#include <Protocol/DriverHealth.h>\r
+\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/PcdLib.h>\r
+#include <Library/ShellCommandLib.h>\r
+#include <Library/ShellLib.h>\r
+#include <Library/SortLib.h>\r
+#include <Library/UefiLib.h>\r
+#include <Library/UefiRuntimeServicesTableLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/HiiLib.h>\r
+#include <Library/FileHandleLib.h>\r
+#include <Library/DevicePathLib.h>\r
+#include <Library/PrintLib.h>\r
+#include <Library/HandleParsingLib.h>\r
+#include <Library/PeCoffGetEntryPointLib.h>\r
+\r
+\r
+extern EFI_HANDLE gShellDriver1HiiHandle;\r
+extern CONST EFI_GUID gShellDriver1HiiGuid;\r
+\r
+/**\r
+ Function for 'connect' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunConnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'devices' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDevices (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'openinfo' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunOpenInfo (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'devtree' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDevTree (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'dh' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDh (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'disconnect' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDisconnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'drivers' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrivers (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'drvcfg' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrvCfg (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'drvdiag' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunDrvDiag (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'reconnect' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunReconnect (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
+/**\r
+ Function for 'unload' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunUnload (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ );\r
+\r
--- /dev/null
+## @file\r
+# Provides shell driver1 profile functions\r
+#\r
+# Copyright (c) 2010, Intel Corporation.All rights reserved. <BR>\r
+#\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
+# 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
+#\r
+#\r
+##\r
+[Defines]\r
+ INF_VERSION = 0x00010006\r
+ BASE_NAME = UefiShellDriver1CommandsLib\r
+ FILE_GUID = 313D3674-3ED4-48fd-BF97-7DB35D4190D1\r
+ MODULE_TYPE = UEFI_DRIVER\r
+ VERSION_STRING = 1.0\r
+ LIBRARY_CLASS = NULL|UEFI_APPLICATION UEFI_DRIVER\r
+ CONSTRUCTOR = UefiShellDriver1CommandsLibConstructor\r
+ DESTRUCTOR = UefiShellDriver1CommandsLibDestructor\r
+\r
+[Sources]\r
+ Connect.c\r
+ Devices.c\r
+ OpenInfo.c\r
+ Disconnect.c\r
+ Reconnect.c\r
+ Unload.c\r
+ DrvDiag.c\r
+ Dh.c\r
+ Drivers.c\r
+ DevTree.c\r
+ DrvCfg.c\r
+ UefiShellDriver1CommandsLib.c\r
+ UefiShellDriver1CommandsLib.h\r
+ UefiShellDriver1CommandsLib.uni\r
+\r
+[Packages]\r
+ MdePkg/MdePkg.dec\r
+ ShellPkg/ShellPkg.dec\r
+ MdeModulePkg/MdeModulePkg.dec\r
+\r
+[LibraryClasses]\r
+ MemoryAllocationLib\r
+ BaseLib\r
+ BaseMemoryLib\r
+ DebugLib\r
+ ShellCommandLib\r
+ ShellLib\r
+ UefiLib\r
+ UefiRuntimeServicesTableLib\r
+ UefiBootServicesTableLib\r
+ SortLib\r
+ PrintLib\r
+ PeCoffGetEntryPointLib\r
+\r
+[Pcd]\r
+ gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask # ALWAYS_CONSUMED\r
+\r
+[Protocols]\r
+ gEfiDriverHealthProtocolGuid # ALWAYS_CONSUMED\r
+ gEfiDriverFamilyOverrideProtocolGuid # ALWAYS_CONSUMED\r
+ gEfiHiiConfigAccessProtocolGuid # ALWAYS_CONSUMED\r
+ gEfiHiiDatabaseProtocolGuid # ALWAYS_CONSUMED\r
+\r
+[Guids]\r
+ gEfiGlobalVariableGuid # ALWAYS_CONSUMED\r
+ gEfiConsoleInDeviceGuid # ALWAYS_CONSUMED\r
+ gEfiConsoleOutDeviceGuid # ALWAYS_CONSUMED\r
+\r
--- /dev/null
+/** @file\r
+ Main file for Unload shell Driver1 function.\r
+\r
+ Copyright (c) 2010, 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
+\r
+**/\r
+\r
+#include "UefiShellDriver1CommandsLib.h"\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
+EFIAPI\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 dump LoadedImage info from TheHandle.\r
+\r
+ @param[in] TheHandle The handle to dump info from.\r
+\r
+ @retval EFI_SUCCESS The info was dumped.\r
+ @retval EFI_INVALID_PARAMETER The handle did not have LoadedImage\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+DumpLoadedImageProtocolInfo (\r
+ IN EFI_HANDLE TheHandle\r
+ )\r
+{\r
+ EFI_LOADED_IMAGE_PROTOCOL *Image;\r
+ EFI_STATUS Status;\r
+ EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevicePathToText;\r
+ CHAR16 *DevicePathText;\r
+ CHAR16 *CodeTypeText;\r
+ CHAR16 *DataTypeText;\r
+ CHAR8 *PdbPointer;\r
+\r
+ Image = NULL;\r
+\r
+ Status = gBS->OpenProtocol(TheHandle, &gEfiLoadedImageProtocolGuid, (VOID**)&Image, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+ if (EFI_ERROR(Status)) {\r
+ return (EFI_INVALID_PARAMETER);\r
+ }\r
+\r
+ Status = gBS->LocateProtocol(\r
+ &gEfiDevicePathToTextProtocolGuid,\r
+ NULL,\r
+ (VOID**)&DevicePathToText);\r
+ //\r
+ // we now have the device path to text protocol\r
+ //\r
+ if (!EFI_ERROR(Status)) {\r
+ DevicePathText = DevicePathToText->ConvertDevicePathToText(Image->FilePath, TRUE, TRUE);\r
+ } else {\r
+ DevicePathText = NULL;\r
+ }\r
+\r
+ CodeTypeText = ConvertMemoryType(Image->ImageCodeType);\r
+ DataTypeText = ConvertMemoryType(Image->ImageDataType);\r
+ PdbPointer = (CHAR8*)PeCoffLoaderGetPdbPointer(Image->ImageBase);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_UNLOAD_VERBOSE), gShellDriver1HiiHandle,\r
+ ConvertHandleToHandleIndex(TheHandle),\r
+ TheHandle,\r
+ Image,\r
+ Image->ParentHandle,\r
+ Image->SystemTable,\r
+ Image->DeviceHandle,\r
+ DevicePathText,\r
+ PdbPointer,\r
+ Image->ImageBase,\r
+ Image->ImageSize,\r
+ CodeTypeText,\r
+ DataTypeText\r
+ );\r
+\r
+ SHELL_FREE_NON_NULL(DevicePathText);\r
+ SHELL_FREE_NON_NULL(CodeTypeText);\r
+ SHELL_FREE_NON_NULL(DataTypeText);\r
+\r
+ return (EFI_SUCCESS);\r
+}\r
+\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+ {L"-n", TypeFlag},\r
+ {L"-v", TypeFlag},\r
+ {L"-verbose", TypeFlag},\r
+ {NULL, TypeMax}\r
+ };\r
+\r
+/**\r
+ Function for 'unload' command.\r
+\r
+ @param[in] ImageHandle Handle to the Image (NULL if Internal).\r
+ @param[in] SystemTable Pointer to the System Table (NULL if Internal).\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellCommandRunUnload (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Package;\r
+ CHAR16 *ProblemParam;\r
+ SHELL_STATUS ShellStatus;\r
+ EFI_HANDLE TheHandle;\r
+ CONST CHAR16 *Param1;\r
+ SHELL_PROMPT_RESPONSE *Resp;\r
+\r
+ ShellStatus = SHELL_SUCCESS;\r
+ Package = NULL;\r
+ Resp = NULL;\r
+\r
+ //\r
+ // initialize the shell lib (we must be in non-auto-init...)\r
+ //\r
+ Status = ShellInitialize();\r
+ ASSERT_EFI_ERROR(Status);\r
+\r
+ //\r
+ // parse the command line\r
+ //\r
+ Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);\r
+ if (EFI_ERROR(Status)) {\r
+ if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);\r
+ FreePool(ProblemParam);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ ASSERT(FALSE);\r
+ }\r
+ } else {\r
+ if (ShellCommandLineGetCount(Package) > 2){\r
+ //\r
+ // error for too many parameters\r
+ //\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (ShellCommandLineGetCount(Package) < 2) {\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDriver1HiiHandle);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ Param1 = ShellCommandLineGetRawValue(Package, 1);\r
+ if (Param1 == NULL || ConvertHandleIndexToHandle(StrHexToUintn(Param1)) == NULL){\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param1);\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else {\r
+ TheHandle = ConvertHandleIndexToHandle(StrHexToUintn(Param1));\r
+ ASSERT(TheHandle != NULL);\r
+ if (ShellCommandLineGetFlag(Package, L"-v") || ShellCommandLineGetFlag(Package, L"-verbose")) {\r
+ DumpLoadedImageProtocolInfo(TheHandle);\r
+ }\r
+ \r
+ if (!ShellCommandLineGetFlag(Package, L"-n")) {\r
+ Status = ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_UNLOAD_CONF), gShellDriver1HiiHandle, StrHexToUintn(Param1));\r
+ Status = ShellPromptForResponse(ShellPromptResponseTypeYesNo, NULL, (VOID**)&Resp);\r
+ }\r
+ if (ShellCommandLineGetFlag(Package, L"-n") || (Resp != NULL && *Resp == ShellPromptResponseYes)) {\r
+ Status = gBS->UnloadImage(TheHandle);\r
+ ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Unload", StrHexToUintn(Param1), Status);\r
+ }\r
+ SHELL_FREE_NON_NULL(Resp);\r
+ }\r
+ }\r
+ }\r
+ if (ShellStatus == SHELL_SUCCESS) {\r
+ if (Status == EFI_SECURITY_VIOLATION) {\r
+ ShellStatus = SHELL_SECURITY_VIOLATION;\r
+ } else if (Status == EFI_INVALID_PARAMETER) {\r
+ ShellStatus = SHELL_INVALID_PARAMETER;\r
+ } else if (EFI_ERROR(Status)) {\r
+ ShellStatus = SHELL_NOT_FOUND;\r
+ }\r
+ }\r
+\r
+ if (Package != NULL) {\r
+ ShellCommandLineFreeVarList(Package);\r
+ }\r
+\r
+ return (ShellStatus);\r
+}\r
projects / mirror_edk2.git / commitdiff