xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeCrPkg/ConfigUtility/CrConfigUtilDxe/CrConfigUtil.c

787 lines
25 KiB
C
Raw Blame History

/** @file
Initial and callback functions for Console Redirection Configuration
;******************************************************************************
;* Copyright (c) 2015 - 2018, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "CrConfigUtil.h"
#include "CrDeviceMenu.h"
#include "CrCallback.h"
#include "CrPolicyType.h"
#include "CrConfig.h"
CR_CONFIG_MANAGER_PRIVATE_DATA *mPrivateData = NULL;
CHAR16 *mVariableName = CONSOLE_REDIRECTION_VARSTORE_NAME;
HII_VENDOR_DEVICE_PATH mHiiVendorDevicePath0 = {
{
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
{
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
}
},
CONSOLE_REDIRECTION_FORMSET_GUID
},
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{
(UINT8) (END_DEVICE_PATH_LENGTH),
(UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
}
}
};
/**
This function allows a caller to extract the current configuration for one
or more named elements from the target driver.
@param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
@param Request A null-terminated Unicode string in
<ConfigRequest> format.
@param Progress On return, points to a character in the Request
string. Points to the string's null terminator if
request was successful. Points to the most recent
'&' before the first failing name/value pair (or
the beginning of the string if the failure is in
the first name/value pair) if the request was not
successful.
@param Results A null-terminated Unicode string in
<ConfigAltResp> format which has all values filled
in for the names in the Request string. String to
be allocated by the called function.
@retval EFI_SUCCESS The Results is filled with the requested values.
@retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
@retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
@retval EFI_NOT_FOUND Routing data doesn't match any storage in this
driver.
**/
EFI_STATUS
EFIAPI
ExtractConfig (
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
IN CONST EFI_STRING Request,
OUT EFI_STRING *Progress,
OUT EFI_STRING *Results
)
{
EFI_STATUS Status;
UINTN BufferSize;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
EFI_STRING ConfigRequest;
EFI_STRING ConfigRequestHdr;
UINTN Size;
BOOLEAN AllocatedRequest;
EFI_STRING Value;
UINTN ValueStrLen;
UINT8 MyNameValue0;
CHAR16 BackupChar;
CHAR16 *StrPointer;
DEBUG ((EFI_D_INFO, "CRExtract: Start\n"));
if (Progress == NULL || Results == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize the local variables.
//
ConfigRequestHdr = NULL;
ConfigRequest = NULL;
Size = 0;
*Progress = Request;
AllocatedRequest = FALSE;
HiiConfigRouting = mPrivateData->HiiConfigRouting;
//
// Get Buffer Storage data from EFI variable.
// Try to get the current setting from variable.
//
BufferSize = sizeof (CR_CONFIGURATION);
Status = gRT->GetVariable (
mVariableName,
&gH2OCrConfigurationGuid,
NULL,
&BufferSize,
&mPrivateData->Configuration
);
if (EFI_ERROR (Status)) {
return EFI_NOT_FOUND;
}
if (Request == NULL) {
//
// Request is set to NULL, construct full request string.
//
//
// Allocate and fill a buffer large enough to hold the <ConfigHdr> template
// followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
//
ConfigRequestHdr = HiiConstructConfigHdr (&gH2OCrConfigurationGuid, mVariableName, mPrivateData->DriverHandle);
if (ConfigRequestHdr == NULL) {
ASSERT (FALSE);
return EFI_OUT_OF_RESOURCES;
}
Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
ConfigRequest = AllocateZeroPool (Size);
if (ConfigRequest == NULL) {
ASSERT (FALSE);
return EFI_OUT_OF_RESOURCES;
}
AllocatedRequest = TRUE;
UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
FreePool (ConfigRequestHdr);
ConfigRequestHdr = NULL;
} else {
//
// Check routing data in <ConfigHdr>.
// Note: if only one Storage is used, then this checking could be skipped.
//
if (!HiiIsConfigHdrMatch (Request, &gH2OCrConfigurationGuid, NULL)) {
return EFI_NOT_FOUND;
}
//
// Check whether request for EFI Varstore. EFI varstore get data
// through hii database, not support in this path.
//
if (!HiiIsConfigHdrMatch (Request, &gH2OCrConfigurationGuid, mVariableName)) {
return EFI_NOT_FOUND;
}
//
// Set Request to the unified request string.
//
ConfigRequest = Request;
//
// Check whether Request includes Request Element.
//
if (StrStr (Request, L"OFFSET") == NULL) {
//
// Check Request Element does exist in Reques String
//
StrPointer = StrStr (Request, L"PATH");
if (StrPointer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (StrStr (StrPointer, L"&") == NULL) {
Size = (StrLen (Request) + 32 + 1) * sizeof (CHAR16);
ConfigRequest = AllocateZeroPool (Size);
ASSERT (ConfigRequest != NULL);
AllocatedRequest = TRUE;
UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", Request, (UINT64)BufferSize);
}
}
}
if (StrStr (ConfigRequest, L"OFFSET") == NULL) {
//
// If requesting Name/Value storage, return value 0.
//
//
// Allocate memory for <ConfigResp>, e.g. Name0=0x11, Name1=0x1234, Name2="ABCD"
// <Request> ::=<ConfigHdr>&Name0&Name1&Name2
// <ConfigResp>::=<ConfigHdr>&Name0=11&Name1=1234&Name2=0041004200430044
//
BufferSize = (StrLen (ConfigRequest) + 1 + sizeof (MyNameValue0) * 2 + 1) * sizeof (CHAR16);
*Results = AllocateZeroPool (BufferSize);
if (*Results == NULL) {
ASSERT (FALSE);
return EFI_OUT_OF_RESOURCES;
}
StrCpyS (*Results, BufferSize / sizeof(CHAR16), ConfigRequest);
Value = *Results;
//
// Append value of NameValueVar0, type is UINT8
//
if ((Value = StrStr (*Results, L"MyNameValue0")) != NULL) {
MyNameValue0 = 0;
Value += StrLen (L"MyNameValue0");
ValueStrLen = ((sizeof (MyNameValue0) * 2) + 1);
CopyMem (&Value[ValueStrLen], Value, StrSize (Value));
BackupChar = Value[ValueStrLen];
*Value++ = L'=';
Value += UnicodeValueToStringS (
Value,
sizeof (CHAR16) * (1 + 1),
PREFIX_ZERO | RADIX_HEX,
MyNameValue0,
sizeof (MyNameValue0) * 2
);
*Value = BackupChar;
}
return EFI_SUCCESS;
}
Status = HiiConfigRouting->BlockToConfig (
HiiConfigRouting,
ConfigRequest,
(UINT8 *)&mPrivateData->Configuration,
sizeof(CR_CONFIGURATION),
Results,
Progress
);
if (EFI_ERROR (Status)) {
return Status;
}
ConfigRequestHdr = HiiConstructConfigHdr (&gH2OCrConfigurationGuid, mVariableName, mPrivateData->DriverHandle);
//
// Free the allocated config request string.
//
if (AllocatedRequest) {
FreePool (ConfigRequest);
}
if (ConfigRequestHdr != NULL) {
FreePool (ConfigRequestHdr);
}
//
// Set Progress string to the original request string.
//
if (Request == NULL) {
*Progress = NULL;
} else if (StrStr (Request, L"OFFSET") == NULL) {
*Progress = Request + StrLen (Request);
}
DEBUG ((EFI_D_INFO, "CRExtract: End\n"));
return EFI_SUCCESS;
}
/**
This function processes the results of changes in configuration.
@param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
@param Configuration A null-terminated Unicode string in <ConfigResp>
format.
@param Progress A pointer to a string filled in with the offset of
the most recent '&' before the first failing
name/value pair (or the beginning of the string if
the failure is in the first name/value pair) or
the terminating NULL if all was successful.
@retval EFI_SUCCESS The Results is processed successfully.
@retval EFI_INVALID_PARAMETER Configuration is NULL.
@retval EFI_NOT_FOUND Routing data doesn't match any storage in this
driver.
**/
EFI_STATUS
EFIAPI
RouteConfig (
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
IN CONST EFI_STRING Configuration,
OUT EFI_STRING *Progress
)
{
//- CR_CONFIGURATION CrConfig;
EFI_STATUS Status;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
UINTN BufferSize;
DEBUG ((EFI_D_INFO, "CRRoutet: Start\n"));
if (Configuration == NULL || Progress == NULL || This == NULL) {
return EFI_INVALID_PARAMETER;
}
*Progress = Configuration;
if (!HiiIsConfigHdrMatch(Configuration, &gH2OCrConfigurationGuid, mVariableName)) {
return EFI_NOT_FOUND;
}
HiiConfigRouting = mPrivateData->HiiConfigRouting;
BufferSize = sizeof (CR_CONFIGURATION);
Status = HiiConfigRouting->ConfigToBlock (
HiiConfigRouting,
Configuration,
(UINT8 *) &mPrivateData->Configuration,
&BufferSize,
Progress
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Store broswer data Buffer Storage to EFI variable
//
Status = CommonSetVariable (
mVariableName,
&gH2OCrConfigurationGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (CR_CONFIGURATION),
&mPrivateData->Configuration
);
DEBUG ((EFI_D_INFO, "CRRoutet: End\n"));
CrSubmit ();
return Status;
}
/**
This function processes the results of changes in configuration.
@param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
@param Action Specifies the type of action taken by the browser.
@param QuestionId A unique value which is sent to the original
exporting driver so that it can identify the type
of data to expect.
@param Type The type of value for the question.
@param Value A pointer to the data being sent to the original
exporting driver.
@param ActionRequest On return, points to the action requested by the
callback function.
@retval EFI_SUCCESS The callback successfully handled the action.
@retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the
variable and its data.
@retval EFI_DEVICE_ERROR The variable could not be saved.
@retval EFI_UNSUPPORTED The specified Action is not supported by the
callback.
**/
EFI_STATUS
EFIAPI
DriverCallback (
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
IN EFI_BROWSER_ACTION Action,
IN EFI_QUESTION_ID QuestionId,
IN UINT8 Type,
IN EFI_IFR_TYPE_VALUE *Value,
OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
)
{
return CrDriverCallback (This, Action, QuestionId, Type, Value, ActionRequest);
}
/**
Unloads the application and its installed protocol.
@param[in] ImageHandle Handle that identifies the image to be unloaded.
@retval EFI_SUCCESS The image has been unloaded.
**/
EFI_STATUS
EFIAPI
SetupUnload (
IN EFI_HANDLE ImageHandle
)
{
DestroyDevices ();
ASSERT (mPrivateData != NULL);
if (mPrivateData->DriverHandle != NULL) {
gBS->UninstallMultipleProtocolInterfaces (
mPrivateData->DriverHandle,
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath0,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
mPrivateData->DriverHandle = NULL;
}
if (mPrivateData->HiiHandle != NULL) {
HiiRemovePackages (mPrivateData->HiiHandle);
}
FreePool (mPrivateData);
mPrivateData = NULL;
return EFI_SUCCESS;
}
/**
Entering SetupUtility notify function.
@param Event Event whose notification function is being invoked.
@param Context The pointer to the notification function's context,
which is implementation-dependent.
@retval EFI_SUCESS This function always complete successfully.
**/
VOID
EFIAPI
SetupUtilityNotify (
IN EFI_EVENT Event,
IN VOID *Context
)
{
CrUpdateMenu (mPrivateData->HiiHandle);
}
VOID
CrCreatePolicyVariable (
VOID
)
{
CR_POLICY_VARIABLE *CrPolicyVar;
CR_POLICY_PCD *CrPolicyPcd;
CR_CONFIGURATION *CrConfig;
UINTN Index;
UINT8 *PcdPtr8;
CrPolicyVar = NULL;
CrPolicyPcd = NULL;
CrConfig = NULL;
//
// Get CR setting info from CrPolicy & CrConfig Variable
//
CrConfig = CommonGetVariableData (mVariableName, &gH2OCrConfigurationGuid);
if (CrConfig == NULL) {
ASSERT (0);
goto exit;
}
if (CrConfig->CREnable == FALSE) {
goto exit;
}
CrPolicyVar = CommonGetVariableData (CR_POLICY_NAME, &gH2OCrConfigurationGuid);
if (CrPolicyVar == NULL) {
CrPolicyVar = AllocateZeroPool (sizeof (CR_POLICY_VARIABLE));
if (CrPolicyVar == NULL) {
ASSERT (0);
goto exit;
}
}
//
// Update CrPolicy feature flag from PCD
//
CrPolicyPcd = (CR_POLICY_PCD*)PcdGetPtr (PcdH2OCrPolicy);
PcdPtr8 = (UINT8*)CrPolicyPcd;
for (Index = 0; PcdPtr8[Index] != 0xFF; Index++) {
if (PcdPtr8[Index] == 1) {
CrPolicyVar->Feature.Data32 |= (UINT32)(1 << Index);
} else {
CrPolicyVar->Feature.Data32 &= (UINT32)(~(1 << Index));
}
}
//
// Update CrPolicy setting from PCD
//
CrPolicyVar->CRWriteCharInterval = CrPolicyPcd->CRWriteCharInterval;
CrPolicyVar->CRFifoLength = CrPolicyPcd->CRFifoLength;
//
// Update CrPolicy setting from SCU(CrConfig)
//
CrPolicyVar->Feature.Bit.CRAutoRefresh = CrConfig->AutoRefresh;
CrPolicyVar->Feature.Bit.CRFailSaveBaudrate = CrConfig->FailSaveBaudRate;
CrPolicyVar->Feature.Bit.CRAfterPost = CrConfig->CRAfterPost;
CrPolicyVar->Feature.Bit.CRTerminalResize = CrConfig->TerminalResize;
CrPolicyVar->CRInfoWaitTime = CrConfig->CRInfoWaitTime;
CrPolicyVar->GlobalBaudRate = CrConfig->GlobalBaudRate;
CrPolicyVar->GlobalParity = CrConfig->GlobalParity;
CrPolicyVar->GlobalDataBits = CrConfig->GlobalDataBits;
CrPolicyVar->GlobalStopBits = CrConfig->GlobalStopBits;
CrPolicyVar->GlobalFlowControl = CrConfig->GlobalFlowControl;
CrPolicyVar->GlobalTerminalType = CrConfig->GlobalTerminalType;
switch (CrConfig->CRTextModeResolution) {
case CR_TEXT_MODE_AUTO:
CrPolicyVar->Feature.Bit.CRForce80x25 = FALSE;
break;
case CR_TEXT_MODE_80X25:
CrPolicyVar->Feature.Bit.CRForce80x25 = TRUE;
CrPolicyVar->Feature.Bit.CRTerminalRows = CR_TERMINAL_ROW_25;
break;
case CR_TEXT_MODE_80X24DF:
CrPolicyVar->Feature.Bit.CRForce80x25 = TRUE;
CrPolicyVar->Feature.Bit.CRTerminalRows = (CR_TERMINAL_ROW_24 == 0)? 0 : 1;
CrPolicyVar->Feature.Bit.CR24RowsPolicy = (CR_24ROWS_POLICY_DEL_FIRST == 0)? 0 : 1;
break;
case CR_TEXT_MODE_80X24DL:
CrPolicyVar->Feature.Bit.CRForce80x25 = TRUE;
CrPolicyVar->Feature.Bit.CRTerminalRows = (CR_TERMINAL_ROW_24 == 0)? 0 : 1;
CrPolicyVar->Feature.Bit.CR24RowsPolicy = (CR_24ROWS_POLICY_DEL_LAST == 0)? 0 : 1;
break;
case CR_TEXT_MODE_128X40:
CrPolicyVar->Feature.Bit.CRForce80x25 = FALSE;
CrPolicyVar->Feature.Bit.CRForce128x40 = TRUE;
break;
default:
break;
}
//
// Due to HyperTerm don't support graphic CharSet,
// if CRForce80x25 as TRUE, always use ASCII CharSet
//
if (CrPolicyVar->Feature.Bit.CRForce80x25) {
CrPolicyVar->Feature.Bit.CRTerminalCharSet = (CR_TERMINAL_CHARSET_ASCII == 0)? 0 : 1;
} else {
CrPolicyVar->Feature.Bit.CRTerminalCharSet = (CR_TERMINAL_CHARSET_GRAPHIC == 0)? 0 : 1;
}
if ((CrPolicyVar->Feature.Bit.CRAsyncTerm == CR_ASYNC_TERMINAL_DISABLE) ||
(FeaturePcdGet(PcdH2OCrSrvManagerSupported))) {
CrPolicyVar->Feature.Bit.CRAutoRefresh = (CR_AUTO_REFRESH_DISABLE == 0)? 0 : 1;
}
//
//CrPolicy : if AutoRefresh support, the ManualRefresh need always support
//
if (CrPolicyVar->Feature.Bit.CRAutoRefresh == TRUE) {
CrPolicyVar->Feature.Bit.CRManualRefresh = TRUE;
}
CommonSetVariable (
CR_POLICY_NAME,
&gH2OCrConfigurationGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof (CR_POLICY_VARIABLE),
CrPolicyVar
);
exit:
if (CrPolicyVar != NULL) {
FreePool(CrPolicyVar);
}
if (CrConfig != NULL) {
FreePool(CrConfig);
}
}
/**
Initialization for the Setup related functions.
@param ImageHandle Image handle this driver.
@param SystemTable Pointer to SystemTable.
@retval EFI_SUCESS This function always complete successfully.
**/
EFI_STATUS
EFIAPI
CrConfigUtilEntry (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_HII_HANDLE HiiHandle;
EFI_HII_STRING_PROTOCOL *HiiString;
EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
CHAR16 *NewString;
CR_CONFIGURATION *CrConfig;
VOID *Registration;
EFI_EVENT Event;
UINTN BufferSize;
BOOLEAN ActionFlag;
EFI_STRING ConfigRequestHdr;
//
// Initialize the local variables.
//
ConfigRequestHdr = NULL;
NewString = NULL;
//
// Initialize configuration data
//
CrConfigVarInit();
//
// Init Cr device Variables
//
PcdDevicesToVariables (FALSE);
//
// Init CrPolicy Setting
//
CrCreatePolicyVariable ();
//
// Initialize driver private data
//
mPrivateData = AllocateZeroPool (sizeof (CR_CONFIG_MANAGER_PRIVATE_DATA));
if (mPrivateData == NULL) {
return EFI_OUT_OF_RESOURCES;
}
mPrivateData->Signature = CR_CONFIG_MAMAGER_PRIVATE_SIGNATURE;
mPrivateData->ConfigAccess.ExtractConfig = ExtractConfig;
mPrivateData->ConfigAccess.RouteConfig = RouteConfig;
mPrivateData->ConfigAccess.Callback = DriverCallback;
//
// Cr Device List
//
InitializeListHead (&mPrivateData->CrDevListHead);
//
// Locate Hii Database protocol
//
Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &HiiDatabase);
if (EFI_ERROR (Status)) {
return Status;
}
mPrivateData->HiiDatabase = HiiDatabase;
//
// Locate HiiString protocol
//
Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &HiiString);
if (EFI_ERROR (Status)) {
return Status;
}
mPrivateData->HiiString = HiiString;
//
// Locate ConfigRouting protocol
//
Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
if (EFI_ERROR (Status)) {
return Status;
}
mPrivateData->HiiConfigRouting = HiiConfigRouting;
Status = gBS->InstallMultipleProtocolInterfaces (
&mPrivateData->DriverHandle,
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath0,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
ASSERT_EFI_ERROR (Status);
//
// Publish our HII data
//
HiiHandle = HiiAddPackages (
&gH2OCrFormsetGuid,
mPrivateData->DriverHandle,
CrConfigUtilStrings,
CrConfigUtilVfrBin,
NULL
);
if (HiiHandle == NULL) {
return EFI_OUT_OF_RESOURCES;
}
mPrivateData->HiiHandle = HiiHandle;
CrConfig = &mPrivateData->Configuration;
ZeroMem (CrConfig, sizeof (CR_CONFIGURATION));
//
// Try to read NV config EFI variable first
//
ConfigRequestHdr = HiiConstructConfigHdr (&gH2OCrConfigurationGuid, mVariableName, mPrivateData->DriverHandle);
ASSERT (ConfigRequestHdr != NULL);
if (ConfigRequestHdr == NULL) {
return EFI_OUT_OF_RESOURCES;
}
DEBUG ((DEBUG_INFO, "ConfigRequestHdr: %s\n", ConfigRequestHdr));
BufferSize = sizeof (CR_CONFIGURATION);
Status = gRT->GetVariable (mVariableName, &gH2OCrConfigurationGuid, NULL, &BufferSize, CrConfig);
//[-start-180823-IB10920058-modify]//
if (EFI_ERROR (Status) || (Status == EFI_SUCCESS && !IsVariableInVariableStoreRegion (mVariableName, &gH2OCrConfigurationGuid))) {
//[-end-180823-IB10920058-modify]//
//[-start-180904-IB10920058-add]//
BufferSize = sizeof (CR_CONFIGURATION);
Status = InitVarDefault (mVariableName, &gH2OCrConfigurationGuid, &BufferSize, CrConfig);
if (EFI_ERROR (Status)) {
SetupUnload (ImageHandle);
return Status;
}
//[-end-180904-IB10920058-add]//
//[-start-180823-IB10920058-remove]//
// //
// // Store zero data Buffer Storage to EFI variable
// //
// Status = CommonSetVariable (
// mVariableName,
// &gH2OCrConfigurationGuid,
// EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
// sizeof (CR_CONFIGURATION),
// CrConfig
// );
// if (EFI_ERROR (Status)) {
// SetupUnload (ImageHandle);
// return Status;
// }
// //
// // EFI variable for NV config doesn't exit, we should build this variable
// // based on default values stored in IFR
// //
//
// ActionFlag = HiiSetToDefaults (ConfigRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
// if (!ActionFlag) {
// SetupUnload (ImageHandle);
// return EFI_INVALID_PARAMETER;
// }
//[-end-180823-IB10920058-remove]//
} else {
//
// EFI variable does exist and Validate Current Setting
//
ActionFlag = HiiValidateSettings (ConfigRequestHdr);
if (!ActionFlag) {
SetupUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
}
FreePool (ConfigRequestHdr);
//
// When execute Setup Utility application, install HII data
//
Status = gBS->CreateEvent (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK - 1,
SetupUtilityNotify,
NULL,
&Event
);
if (!EFI_ERROR (Status)) {
Status = gBS->RegisterProtocolNotify (
&gEfiSetupUtilityApplicationProtocolGuid,
Event,
&Registration
);
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink