774 lines
25 KiB
C
774 lines
25 KiB
C
/** @file
|
|
|
|
Initial and callback functions for SOL 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 <SolConfigUtil.h>
|
|
|
|
EFI_HANDLE mDriverHandle = NULL;
|
|
SOL_CONFIG_UTIL_PRIVATE_DATA *mPrivateData = NULL;
|
|
|
|
//[-start-160407-IB14090058-remove]//
|
|
//BOOLEAN mFirstBoot = FALSE;
|
|
//[-end-160407-IB14090058-remove]//
|
|
UINT8 mMyNameValue = 0;
|
|
CHAR16 mVariableName[] = SOL_VARSTORE_NAME;
|
|
HII_VENDOR_DEVICE_PATH mHiiVendorDevicePath0 = {
|
|
{
|
|
{
|
|
HARDWARE_DEVICE_PATH,
|
|
HW_VENDOR_DP,
|
|
{
|
|
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
|
|
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
|
|
}
|
|
},
|
|
SOL_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;
|
|
//[-start-180508-IB08400589-add]//
|
|
CHAR16 *StrPointer;
|
|
//[-end-180508-IB08400589-add]//
|
|
|
|
DEBUG ((EFI_D_INFO, "SolExtract: 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 (SOL_CONFIGURATION);
|
|
Status = gRT->GetVariable (
|
|
mVariableName,
|
|
&gH2OSolConfigUtilVarstoreGuid,
|
|
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 (&gH2OSolConfigUtilVarstoreGuid, mVariableName, mPrivateData->DriverHandle);
|
|
Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
|
|
ConfigRequest = AllocateZeroPool (Size);
|
|
ASSERT (ConfigRequest != NULL);
|
|
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, &gH2OSolConfigUtilVarstoreGuid, 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, &gH2OSolConfigUtilVarstoreGuid, mVariableName)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
//
|
|
// Set Request to the unified request string.
|
|
//
|
|
ConfigRequest = Request;
|
|
//[-start-180508-IB08400589-add]//
|
|
//
|
|
// 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);
|
|
}
|
|
}
|
|
//[-end-180508-IB08400589-add]//
|
|
}
|
|
|
|
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);
|
|
ASSERT (*Results != NULL);
|
|
//[-start-180820-IB08400637-modify]//
|
|
StrCpyS (*Results, BufferSize / sizeof(CHAR16), ConfigRequest);
|
|
//[-end-180820-IB08400637-modify]//
|
|
Value = *Results;
|
|
|
|
//
|
|
// Append value of NameValueVar0, type is UINT8
|
|
//
|
|
if ((Value = StrStr (*Results, L"MyNameValue0")) != NULL) {
|
|
MyNameValue0 = 0;
|
|
|
|
//[-start-180820-IB08400637-modify]//
|
|
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;
|
|
//[-end-180820-IB08400637-modify]//
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//[-start-180508-IB08400589-modify]//
|
|
Status = HiiConfigRouting->BlockToConfig (
|
|
HiiConfigRouting,
|
|
ConfigRequest,
|
|
(UINT8 *)&mPrivateData->Configuration,
|
|
sizeof(SOL_CONFIGURATION),
|
|
Results,
|
|
Progress
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
ConfigRequestHdr = HiiConstructConfigHdr (&gH2OSolConfigUtilVarstoreGuid, mVariableName, mPrivateData->DriverHandle);
|
|
//[-end-180508-IB08400589-modify]//
|
|
|
|
//
|
|
// 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, "SolExtract: 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
|
|
)
|
|
{
|
|
SOL_CONFIGURATION SolConfig = {0};
|
|
EFI_STATUS Status;
|
|
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
|
|
UINTN BufferSize;
|
|
|
|
DEBUG ((EFI_D_INFO, "SolRoutet: Start\n"));
|
|
|
|
if (Configuration == NULL || Progress == NULL || This == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//[-start-180510-IB08400591-add]//
|
|
*Progress = Configuration;
|
|
//[-end-180510-IB08400591-add]//
|
|
|
|
//[-start-180508-IB08400589-modify]//
|
|
if (!HiiIsConfigHdrMatch(Configuration, &gH2OSolConfigUtilVarstoreGuid, mVariableName)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
//[-end-180508-IB08400589-modify]//
|
|
|
|
HiiConfigRouting = mPrivateData->HiiConfigRouting;
|
|
BufferSize = sizeof (SOL_CONFIGURATION);
|
|
Status = HiiConfigRouting->ConfigToBlock (
|
|
HiiConfigRouting,
|
|
Configuration,
|
|
(UINT8 *) &SolConfig,
|
|
&BufferSize,
|
|
Progress
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
//[-start-160104-IB04930000-add]//
|
|
mPrivateData->Configuration.SolEnable = SolConfig.SolEnable;
|
|
mPrivateData->Configuration.UseDhcp = SolConfig.UseDhcp;
|
|
//[-end-160104-IB04930000-add]//
|
|
//
|
|
// Store broswer data Buffer Storage to EFI variable
|
|
//
|
|
Status = CommonSetVariable (
|
|
mVariableName,
|
|
&gH2OSolConfigUtilVarstoreGuid,
|
|
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof (SOL_CONFIGURATION),
|
|
//[-start-160104-IB04930000-modify]//
|
|
&mPrivateData->Configuration
|
|
//[-end-160104-IB04930000-modify]//
|
|
);
|
|
DEBUG ((EFI_D_INFO, "SolRoute: End\n"));
|
|
|
|
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
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
H2O_DIALOG_PROTOCOL *H2ODialog;
|
|
EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
|
|
CHAR16 *ConfigRequest;
|
|
UINTN ConfigRequestSize;
|
|
UINT8 MyNameValue0;
|
|
//[-start-180823-IB10920058-add]//
|
|
SOL_CONFIGURATION Configuration = {0};
|
|
UINTN ConfigSize;
|
|
//[-end-180823-IB10920058-add]//
|
|
|
|
if (((Value == NULL) && (Action != EFI_BROWSER_ACTION_FORM_OPEN) && (Action != EFI_BROWSER_ACTION_FORM_CLOSE))||
|
|
(ActionRequest == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
MyNameValue0 = mMyNameValue + 1;
|
|
mMyNameValue ++;
|
|
Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &FormBrowser2);
|
|
if (!EFI_ERROR (Status)) {
|
|
ConfigRequestSize = 0x100;
|
|
ConfigRequest = AllocateZeroPool (ConfigRequestSize);
|
|
UnicodeSPrint (ConfigRequest, ConfigRequestSize, L"MyNameValue0=%02x", MyNameValue0);
|
|
FormBrowser2->BrowserCallback (
|
|
FormBrowser2,
|
|
&ConfigRequestSize,
|
|
ConfigRequest,
|
|
FALSE,
|
|
&gH2OSolFormsetGuid,
|
|
L"MyNameValue0"
|
|
);
|
|
FreePool (ConfigRequest);
|
|
}
|
|
|
|
Status = EFI_SUCCESS;
|
|
|
|
switch (Action) {
|
|
case EFI_BROWSER_ACTION_FORM_OPEN:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->FORM_OPEN Qid:0x%x Typ:0x%x\n",QuestionId, Type));
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case EFI_BROWSER_ACTION_CHANGING:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->CHANGING Qid:0x%x Typ:0x%x\n",QuestionId, Type));
|
|
{
|
|
Status = gBS->LocateProtocol (
|
|
&gH2ODialogProtocolGuid,
|
|
NULL,
|
|
(VOID **)&H2ODialog
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
switch (QuestionId) {
|
|
//
|
|
// For SOL Callbacks.
|
|
//
|
|
|
|
default:
|
|
//
|
|
// Dynamical Label callback.
|
|
//
|
|
SolUpdateEntrys (&mPrivateData->Configuration);
|
|
SolConfigCallback (QuestionId, &mPrivateData->Configuration);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EFI_BROWSER_ACTION_DEFAULT_MANUFACTURING:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->DEFAULT_MANUFACTURING Qid:0x%x Typ:0x%x\n",QuestionId, Type));
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
|
|
case EFI_BROWSER_ACTION_DEFAULT_STANDARD:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->DEFAULT_STANDARD Qid:0x%x Typ:0x%x\n",QuestionId, Type));
|
|
//[-start-180823-IB10920058-add]//
|
|
if (QuestionId == KEY_LOAD_DEFAULT) {
|
|
//
|
|
// Last question in this formset
|
|
//
|
|
DEBUG ((EFI_D_INFO, "Load VAR default.\n"));
|
|
ConfigSize = sizeof (SOL_CONFIGURATION);
|
|
Status = LoadVarDefault (
|
|
mVariableName,
|
|
&gH2OSolConfigUtilVarstoreGuid,
|
|
&ConfigSize,
|
|
&Configuration
|
|
);
|
|
}
|
|
//[-end-180823-IB10920058-add]//
|
|
if (QuestionId == KEY_LOAD_DEFAULT) {
|
|
//
|
|
// Workaround for SCU init stage calling this function.
|
|
//
|
|
SolConfigSetToDefault (&mPrivateData->Configuration);
|
|
SolUpdateEntrys (&mPrivateData->Configuration);
|
|
} else {
|
|
Status = EFI_UNSUPPORTED;
|
|
}
|
|
break;
|
|
|
|
case EFI_BROWSER_ACTION_RETRIEVE:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->RETRIEVE Qid:0x%x Typ:0x%x\n",QuestionId, Type));
|
|
if (QuestionId == KEY_LOAD_DEFAULT) {
|
|
Status = EFI_SUCCESS;
|
|
} else {
|
|
Status = EFI_UNSUPPORTED;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DEBUG ((EFI_D_INFO, "SolCallBack->default:0x%x Qid:0x%x Typ:0x%x\n",Action ,QuestionId, Type));
|
|
Status = EFI_UNSUPPORTED;
|
|
break;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
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
|
|
)
|
|
{
|
|
|
|
ASSERT (mPrivateData != NULL);
|
|
|
|
if (mDriverHandle != NULL) {
|
|
gBS->UninstallMultipleProtocolInterfaces (
|
|
mDriverHandle,
|
|
&gEfiDevicePathProtocolGuid,
|
|
&mHiiVendorDevicePath0,
|
|
&gEfiHiiConfigAccessProtocolGuid,
|
|
&mPrivateData->ConfigAccess,
|
|
NULL
|
|
);
|
|
mDriverHandle = 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
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Init Sol scu setting
|
|
//
|
|
//[-start-160407-IB14090058-remove]//
|
|
// if (mFirstBoot) {
|
|
// SolConfigSetToDefault (&mPrivateData->Configuration);
|
|
// }
|
|
//[-end-160407-IB14090058-remove]//
|
|
Status = SolConfigFormInit (mPrivateData->HiiHandle, &mPrivateData->Configuration);
|
|
Status = CommonSetVariable (
|
|
mVariableName,
|
|
&gH2OSolConfigUtilVarstoreGuid,
|
|
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof (SOL_CONFIGURATION),
|
|
&mPrivateData->Configuration
|
|
);
|
|
gBS->CloseEvent (Event);
|
|
}
|
|
|
|
/**
|
|
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
|
|
SolConfigUtilEntry (
|
|
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;
|
|
SOL_CONFIGURATION *SolConfig;
|
|
VOID *Registration;
|
|
EFI_EVENT Event;
|
|
UINTN BufferSize;
|
|
BOOLEAN ActionFlag;
|
|
EFI_STRING ConfigRequestHdr;
|
|
|
|
//
|
|
// Initialize the local variables.
|
|
//
|
|
ConfigRequestHdr = NULL;
|
|
NewString = NULL;
|
|
|
|
//
|
|
// Initialize driver private data
|
|
//
|
|
mPrivateData = AllocateZeroPool (sizeof (SOL_CONFIG_UTIL_PRIVATE_DATA));
|
|
if (mPrivateData == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
mPrivateData->Signature = SOL_CONFIG_UTIL_PRIVATE_SIGNATURE;
|
|
|
|
mPrivateData->ConfigAccess.ExtractConfig = ExtractConfig;
|
|
mPrivateData->ConfigAccess.RouteConfig = RouteConfig;
|
|
mPrivateData->ConfigAccess.Callback = DriverCallback;
|
|
|
|
//
|
|
// 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 (
|
|
&mDriverHandle,
|
|
&gEfiDevicePathProtocolGuid,
|
|
&mHiiVendorDevicePath0,
|
|
&gEfiHiiConfigAccessProtocolGuid,
|
|
&mPrivateData->ConfigAccess,
|
|
NULL
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
mPrivateData->DriverHandle = mDriverHandle;
|
|
|
|
//
|
|
// Publish our HII data
|
|
//
|
|
HiiHandle = HiiAddPackages (
|
|
&gH2OSolFormsetGuid,
|
|
mDriverHandle,
|
|
SolConfigUtilStrings,
|
|
SolConfigUtilVfrBin,
|
|
NULL
|
|
);
|
|
if (HiiHandle == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
mPrivateData->HiiHandle = HiiHandle;
|
|
|
|
//
|
|
// Initialize configuration data
|
|
//
|
|
SolConfig = &mPrivateData->Configuration;
|
|
ZeroMem (SolConfig, sizeof (SOL_CONFIGURATION));
|
|
|
|
//
|
|
// Try to read NV config EFI variable first
|
|
//
|
|
ConfigRequestHdr = HiiConstructConfigHdr (&gH2OSolConfigUtilVarstoreGuid, mVariableName, mDriverHandle);
|
|
ASSERT (ConfigRequestHdr != NULL);
|
|
if (ConfigRequestHdr == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
DEBUG ((DEBUG_INFO, "ConfigRequestHdr: %s\n", ConfigRequestHdr));
|
|
|
|
BufferSize = sizeof (SOL_CONFIGURATION);
|
|
Status = gRT->GetVariable (mVariableName, &gH2OSolConfigUtilVarstoreGuid, NULL, &BufferSize, SolConfig);
|
|
//[-start-180823-IB10920058-add]//
|
|
if (EFI_ERROR (Status) || (Status == EFI_SUCCESS && !IsVariableInVariableStoreRegion (mVariableName, &gSolConfigUtilVarstoreGuid))) {
|
|
//[-end-180823-IB10920058-add]//
|
|
//[-start-180904-IB10920058-add]//
|
|
BufferSize = sizeof (SOL_CONFIGURATION);
|
|
Status = InitVarDefault (mVariableName, &gH2OSolConfigUtilVarstoreGuid, &BufferSize, SolConfig);
|
|
if (EFI_ERROR (Status)) {
|
|
SetupUnload (ImageHandle);
|
|
return Status;
|
|
}
|
|
//[-end-180904-IB10920058-add]//
|
|
//[-start-160407-IB14090058-modify]//
|
|
SolConfigSetToDefault (SolConfig);
|
|
//[-end-160407-IB14090058-modify]//
|
|
//[-start-180823-IB10920058-remove]//
|
|
// //
|
|
// // Store zero data Buffer Storage to EFI variable
|
|
// //
|
|
// Status = CommonSetVariable (
|
|
// mVariableName,
|
|
// &gH2OSolConfigUtilVarstoreGuid,
|
|
// EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
// sizeof (SOL_CONFIGURATION),
|
|
// SolConfig
|
|
// );
|
|
// 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;
|
|
}
|