Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-27 16:58:09 +01:00
Code Issues Packages Projects Releases Wiki Activity
fc0b83c34b
CloverBootloader/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c
SergeySlice 01f33f7552 detect unknown linux versions, 
stylish change: remove space between func and brace

Signed-off-by: SergeySlice <sergey.slice@gmail.com>
2020-04-23 12:08:10 +03:00

2240 lines
70 KiB
C
Raw Blame History

/** @file
This is an example of how a driver might export data to the HII protocol to be
later utilized by the Setup Protocol
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "DriverSample.h"
#define DISPLAY_ONLY_MY_ITEM 0x0002
CHAR16 VariableName[] = L"MyIfrNVData";
CHAR16 MyEfiVar[] = L"MyEfiVar";
CHAR16 MyEfiBitVar[] = L"MyEfiBitVar";
CHAR16 MyEfiUnionVar[] = L"MyEfiUnionVar";
EFI_HANDLE DriverHandle[2] = {NULL, NULL};
DRIVER_SAMPLE_PRIVATE_DATA *mPrivateData = NULL;
EFI_EVENT mEvent;
HII_VENDOR_DEVICE_PATH mHiiVendorDevicePath0 = {
{
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
{
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
}
},
DRIVER_SAMPLE_FORMSET_GUID
},
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{
(UINT8) (END_DEVICE_PATH_LENGTH),
(UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
}
}
};
HII_VENDOR_DEVICE_PATH mHiiVendorDevicePath1 = {
{
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
{
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
}
},
DRIVER_SAMPLE_INVENTORY_GUID
},
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{
(UINT8) (END_DEVICE_PATH_LENGTH),
(UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
}
}
};
/**
Set value of a data element in an Array by its Index.
@param Array The data array.
@param Type Type of the data in this array.
@param Index Zero based index for data in this array.
@param Value The value to be set.
**/
VOID
SetArrayData (
IN VOID *Array,
IN UINT8 Type,
IN UINTN Index,
IN UINT64 Value
)
{
ASSERT (Array != NULL);
switch (Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
*(((UINT8 *) Array) + Index) = (UINT8) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
*(((UINT16 *) Array) + Index) = (UINT16) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
*(((UINT32 *) Array) + Index) = (UINT32) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_64:
*(((UINT64 *) Array) + Index) = (UINT64) Value;
break;
default:
break;
}
}
/**
Notification function for keystrokes.
@param[in] KeyData The key that was pressed.
@retval EFI_SUCCESS The operation was successful.
**/
EFI_STATUS
EFIAPI
NotificationFunction(
IN EFI_KEY_DATA *KeyData
)
{
gBS->SignalEvent (mEvent);
return EFI_SUCCESS;
}
/**
Function to start monitoring for CTRL-C using SimpleTextInputEx.
@retval EFI_SUCCESS The feature is enabled.
@retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
**/
EFI_STATUS
EFIAPI
InternalStartMonitor(
VOID
)
{
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;
EFI_KEY_DATA KeyData;
EFI_STATUS Status;
EFI_HANDLE *Handles;
UINTN HandleCount;
UINTN HandleIndex;
EFI_HANDLE NotifyHandle;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextInputExProtocolGuid,
NULL,
&HandleCount,
&Handles
);
for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &SimpleEx);
ASSERT_EFI_ERROR(Status);
KeyData.KeyState.KeyToggleState = 0;
KeyData.Key.ScanCode = 0;
KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
KeyData.Key.UnicodeChar = L'c';
Status = SimpleEx->RegisterKeyNotify(
SimpleEx,
&KeyData,
NotificationFunction,
&NotifyHandle);
if (EFI_ERROR(Status)) {
break;
}
KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
Status = SimpleEx->RegisterKeyNotify(
SimpleEx,
&KeyData,
NotificationFunction,
&NotifyHandle);
if (EFI_ERROR(Status)) {
break;
}
}
return EFI_SUCCESS;
}
/**
Function to stop monitoring for CTRL-C using SimpleTextInputEx.
@retval EFI_SUCCESS The feature is enabled.
@retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
**/
EFI_STATUS
EFIAPI
InternalStopMonitor(
VOID
)
{
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;
EFI_STATUS Status;
EFI_HANDLE *Handles;
EFI_KEY_DATA KeyData;
UINTN HandleCount;
UINTN HandleIndex;
EFI_HANDLE NotifyHandle;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextInputExProtocolGuid,
NULL,
&HandleCount,
&Handles
);
for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &SimpleEx);
ASSERT_EFI_ERROR(Status);
KeyData.KeyState.KeyToggleState = 0;
KeyData.Key.ScanCode = 0;
KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
KeyData.Key.UnicodeChar = L'c';
Status = SimpleEx->RegisterKeyNotify(
SimpleEx,
&KeyData,
NotificationFunction,
&NotifyHandle);
if (!EFI_ERROR(Status)) {
Status = SimpleEx->UnregisterKeyNotify (SimpleEx, NotifyHandle);
}
KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
Status = SimpleEx->RegisterKeyNotify(
SimpleEx,
&KeyData,
NotificationFunction,
&NotifyHandle);
if (!EFI_ERROR(Status)) {
Status = SimpleEx->UnregisterKeyNotify (SimpleEx, NotifyHandle);
}
}
return EFI_SUCCESS;
}
/**
Update names of Name/Value storage to current language.
@param PrivateData Points to the driver private data.
@retval EFI_SUCCESS All names are successfully updated.
@retval EFI_NOT_FOUND Failed to get Name from HII database.
**/
EFI_STATUS
LoadNameValueNames (
IN DRIVER_SAMPLE_PRIVATE_DATA *PrivateData
)
{
UINTN Index;
//
// Get Name/Value name string of current language
//
for (Index = 0; Index < NAME_VALUE_NAME_NUMBER; Index++) {
PrivateData->NameValueName[Index] = HiiGetString (
PrivateData->HiiHandle[0],
PrivateData->NameStringId[Index],
NULL
);
if (PrivateData->NameValueName[Index] == NULL) {
return EFI_NOT_FOUND;
}
}
return EFI_SUCCESS;
}
/**
Get the value of <Number> in <BlockConfig> format, i.e. the value of OFFSET
or WIDTH or VALUE.
<BlockConfig> ::= 'OFFSET='<Number>&'WIDTH='<Number>&'VALUE'=<Number>
This is a internal function.
@param StringPtr String in <BlockConfig> format and points to the
first character of <Number>.
@param Number The output value. Caller takes the responsibility
to free memory.
@param Len Length of the <Number>, in characters.
@retval EFI_OUT_OF_RESOURCES Insufficient resources to store neccessary
structures.
@retval EFI_SUCCESS Value of <Number> is outputted in Number
successfully.
**/
EFI_STATUS
GetValueOfNumber (
IN EFI_STRING StringPtr,
OUT UINT8 **Number,
OUT UINTN *Len
)
{
EFI_STRING TmpPtr;
UINTN Length;
EFI_STRING Str;
UINT8 *Buf;
EFI_STATUS Status;
UINT8 DigitUint8;
UINTN Index;
CHAR16 TemStr[2];
if (StringPtr == NULL || *StringPtr == L'\0' || Number == NULL || Len == NULL) {
return EFI_INVALID_PARAMETER;
}
Buf = NULL;
TmpPtr = StringPtr;
while (*StringPtr != L'\0' && *StringPtr != L'&') {
StringPtr++;
}
*Len = StringPtr - TmpPtr;
Length = *Len + 1;
Str = (EFI_STRING) AllocateZeroPool (Length * sizeof (CHAR16));
if (Str == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Exit;
}
CopyMem (Str, TmpPtr, *Len * sizeof (CHAR16));
*(Str + *Len) = L'\0';
Length = (Length + 1) / 2;
Buf = (UINT8 *) AllocateZeroPool (Length);
if (Buf == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Exit;
}
Length = *Len;
ZeroMem (TemStr, sizeof (TemStr));
for (Index = 0; Index < Length; Index ++) {
TemStr[0] = Str[Length - Index - 1];
DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
if ((Index & 1) == 0) {
Buf [Index/2] = DigitUint8;
} else {
Buf [Index/2] = (UINT8) ((DigitUint8 << 4) + Buf [Index/2]);
}
}
*Number = Buf;
Status = EFI_SUCCESS;
Exit:
if (Str != NULL) {
FreePool(Str);
}
return Status;
}
/**
Create altcfg string.
@param Result The request result string.
@param ConfigHdr The request head info. <ConfigHdr> format.
@param Offset The offset of the parameter int he structure.
@param Width The width of the parameter.
@retval The string with altcfg info append at the end.
**/
EFI_STRING
CreateAltCfgString (
IN EFI_STRING Result,
IN EFI_STRING ConfigHdr,
IN UINTN Offset,
IN UINTN Width
)
{
EFI_STRING StringPtr;
EFI_STRING TmpStr;
UINTN NewLen;
NewLen = StrLen (Result);
//
// String Len = ConfigResp + AltConfig + AltConfig + 1("\0")
//
NewLen = (NewLen + ((1 + StrLen (ConfigHdr) + 8 + 4) + (8 + 4 + 7 + 4 + 7 + 4)) * 2 + 1) * sizeof (CHAR16);
StringPtr = AllocateZeroPool (NewLen);
if (StringPtr == NULL) {
return NULL;
}
TmpStr = StringPtr;
if (Result != NULL) {
StrCpyS (StringPtr, NewLen / sizeof (CHAR16), Result);
StringPtr += StrLen (Result);
FreePool(Result);
}
UnicodeSPrint (
StringPtr,
(1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16),
L"&%s&ALTCFG=%04x",
ConfigHdr,
EFI_HII_DEFAULT_CLASS_STANDARD
);
StringPtr += StrLen (StringPtr);
UnicodeSPrint (
StringPtr,
(8 + 4 + 7 + 4 + 7 + 4 + 1) * sizeof (CHAR16),
L"&OFFSET=%04x&WIDTH=%04x&VALUE=%04x",
Offset,
Width,
DEFAULT_CLASS_STANDARD_VALUE
);
StringPtr += StrLen (StringPtr);
UnicodeSPrint (
StringPtr,
(1 + StrLen (ConfigHdr) + 8 + 4 + 1) * sizeof (CHAR16),
L"&%s&ALTCFG=%04x",
ConfigHdr,
EFI_HII_DEFAULT_CLASS_MANUFACTURING
);
StringPtr += StrLen (StringPtr);
UnicodeSPrint (
StringPtr,
(8 + 4 + 7 + 4 + 7 + 4 + 1) * sizeof (CHAR16),
L"&OFFSET=%04x&WIDTH=%04x&VALUE=%04x",
Offset,
Width,
DEFAULT_CLASS_MANUFACTURING_VALUE
);
StringPtr += StrLen (StringPtr);
return TmpStr;
}
/**
Check whether need to add the altcfg string. if need to add, add the altcfg
string.
@param RequestResult The request result string.
@param ConfigRequestHdr The request head info. <ConfigHdr> format.
**/
VOID
AppendAltCfgString (
IN OUT EFI_STRING *RequestResult,
IN EFI_STRING ConfigRequestHdr
)
{
EFI_STRING StringPtr;
UINTN Length;
UINT8 *TmpBuffer;
UINTN Offset;
UINTN Width;
UINTN BlockSize;
UINTN ValueOffset;
UINTN ValueWidth;
EFI_STATUS Status;
TmpBuffer = NULL;
StringPtr = *RequestResult;
StringPtr = StrStr (StringPtr, L"OFFSET");
BlockSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
ValueOffset = OFFSET_OF (DRIVER_SAMPLE_CONFIGURATION, GetDefaultValueFromAccess);
ValueWidth = sizeof (((DRIVER_SAMPLE_CONFIGURATION *)0)->GetDefaultValueFromAccess);
if (StringPtr == NULL) {
return;
}
while (*StringPtr != 0 && StrnCmp (StringPtr, L"OFFSET=", StrLen (L"OFFSET=")) == 0) {
StringPtr += StrLen (L"OFFSET=");
//
// Get Offset
//
Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
if (EFI_ERROR(Status)) {
return;
}
Offset = 0;
CopyMem (
&Offset,
TmpBuffer,
(((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
);
FreePool(TmpBuffer);
StringPtr += Length;
if (StrnCmp (StringPtr, L"&WIDTH=", StrLen (L"&WIDTH=")) != 0) {
return;
}
StringPtr += StrLen (L"&WIDTH=");
//
// Get Width
//
Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
if (EFI_ERROR(Status)) {
return;
}
Width = 0;
CopyMem (
&Width,
TmpBuffer,
(((Length + 1) / 2) < sizeof (UINTN)) ? ((Length + 1) / 2) : sizeof (UINTN)
);
FreePool(TmpBuffer);
StringPtr += Length;
if (StrnCmp (StringPtr, L"&VALUE=", StrLen (L"&VALUE=")) != 0) {
return;
}
StringPtr += StrLen (L"&VALUE=");
//
// Get Value
//
Status = GetValueOfNumber (StringPtr, &TmpBuffer, &Length);
if (EFI_ERROR(Status)) {
return;
}
StringPtr += Length;
//
// Skip the character "&" before "OFFSET".
//
StringPtr ++;
//
// Calculate Value and convert it to hex string.
//
if (Offset + Width > BlockSize) {
return;
}
if (Offset <= ValueOffset && Offset + Width >= ValueOffset + ValueWidth) {
*RequestResult = CreateAltCfgString(*RequestResult, ConfigRequestHdr, ValueOffset, ValueWidth);
return;
}
}
}
/**
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;
DRIVER_SAMPLE_PRIVATE_DATA *PrivateData;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
EFI_STRING ConfigRequest;
EFI_STRING ConfigRequestHdr;
UINTN Size;
EFI_STRING Value;
UINTN ValueStrLen;
CHAR16 BackupChar;
CHAR16 *StrPointer;
BOOLEAN AllocatedRequest;
if (Progress == NULL || Results == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize the local variables.
//
ConfigRequestHdr = NULL;
ConfigRequest = NULL;
Size = 0;
*Progress = Request;
AllocatedRequest = FALSE;
PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
HiiConfigRouting = PrivateData->HiiConfigRouting;
//
// Get Buffer Storage data from EFI variable.
// Try to get the current setting from variable.
//
BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
Status = gRT->GetVariable (
VariableName,
&gDriverSampleFormSetGuid,
NULL,
&BufferSize,
&PrivateData->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 (&gDriverSampleFormSetGuid, VariableName, PrivateData->DriverHandle[0]);
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, &gDriverSampleFormSetGuid, 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, &gDriverSampleFormSetGuid, MyEfiVar)) {
return EFI_UNSUPPORTED;
}
if (HiiIsConfigHdrMatch(Request, &gDriverSampleFormSetGuid, MyEfiBitVar)) {
return EFI_UNSUPPORTED;
}
if (HiiIsConfigHdrMatch(Request, &gDriverSampleFormSetGuid, MyEfiUnionVar)) {
return EFI_UNSUPPORTED;
}
//
// 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);
}
}
}
//
// Check if requesting Name/Value storage
//
if (StrStr (ConfigRequest, L"OFFSET") == NULL) {
//
// Update Name/Value storage Names
//
Status = LoadNameValueNames (PrivateData);
if (EFI_ERROR(Status)) {
return Status;
}
//
// 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 (PrivateData->Configuration.NameValueVar0) * 2 +
1 + sizeof (PrivateData->Configuration.NameValueVar1) * 2 +
1 + sizeof (PrivateData->Configuration.NameValueVar2) * 2 + 1) * sizeof (CHAR16);
*Results = AllocateZeroPool (BufferSize);
ASSERT (*Results != NULL);
StrCpyS (*Results, BufferSize / sizeof (CHAR16), ConfigRequest);
Value = *Results;
//
// Append value of NameValueVar0, type is UINT8
//
if ((Value = StrStr (*Results, PrivateData->NameValueName[0])) != NULL) {
Value += StrLen (PrivateData->NameValueName[0]);
ValueStrLen = ((sizeof (PrivateData->Configuration.NameValueVar0) * 2) + 1);
CopyMem (Value + ValueStrLen, Value, StrSize (Value));
BackupChar = Value[ValueStrLen];
*Value++ = L'=';
UnicodeValueToStringS (
Value,
BufferSize - ((UINTN)Value - (UINTN)*Results),
PREFIX_ZERO | RADIX_HEX,
PrivateData->Configuration.NameValueVar0,
sizeof (PrivateData->Configuration.NameValueVar0) * 2
);
Value += StrnLenS (Value, (BufferSize - ((UINTN)Value - (UINTN)*Results)) / sizeof (CHAR16));
*Value = BackupChar;
}
//
// Append value of NameValueVar1, type is UINT16
//
if ((Value = StrStr (*Results, PrivateData->NameValueName[1])) != NULL) {
Value += StrLen (PrivateData->NameValueName[1]);
ValueStrLen = ((sizeof (PrivateData->Configuration.NameValueVar1) * 2) + 1);
CopyMem (Value + ValueStrLen, Value, StrSize (Value));
BackupChar = Value[ValueStrLen];
*Value++ = L'=';
UnicodeValueToStringS (
Value,
BufferSize - ((UINTN)Value - (UINTN)*Results),
PREFIX_ZERO | RADIX_HEX,
PrivateData->Configuration.NameValueVar1,
sizeof (PrivateData->Configuration.NameValueVar1) * 2
);
Value += StrnLenS (Value, (BufferSize - ((UINTN)Value - (UINTN)*Results)) / sizeof (CHAR16));
*Value = BackupChar;
}
//
// Append value of NameValueVar2, type is CHAR16 *
//
if ((Value = StrStr (*Results, PrivateData->NameValueName[2])) != NULL) {
Value += StrLen (PrivateData->NameValueName[2]);
ValueStrLen = StrLen (PrivateData->Configuration.NameValueVar2) * 4 + 1;
CopyMem (Value + ValueStrLen, Value, StrSize (Value));
*Value++ = L'=';
//
// Convert Unicode String to Config String, e.g. "ABCD" => "0041004200430044"
//
StrPointer = (CHAR16 *) PrivateData->Configuration.NameValueVar2;
for (; *StrPointer != L'\0'; StrPointer++) {
UnicodeValueToStringS (
Value,
BufferSize - ((UINTN)Value - (UINTN)*Results),
PREFIX_ZERO | RADIX_HEX,
*StrPointer,
4
);
Value += StrnLenS (Value, (BufferSize - ((UINTN)Value - (UINTN)*Results)) / sizeof (CHAR16));
}
}
Status = EFI_SUCCESS;
} else {
//
// Convert buffer data to <ConfigResp> by helper function BlockToConfig()
//
Status = HiiConfigRouting->BlockToConfig (
HiiConfigRouting,
ConfigRequest,
(UINT8 *) &PrivateData->Configuration,
BufferSize,
Results,
Progress
);
if (!EFI_ERROR(Status)) {
ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, VariableName, PrivateData->DriverHandle[0]);
AppendAltCfgString(Results, ConfigRequestHdr);
}
}
//
// 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);
}
return Status;
}
/**
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
)
{
EFI_STATUS Status;
UINTN BufferSize;
DRIVER_SAMPLE_PRIVATE_DATA *PrivateData;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
CHAR16 *Value;
CHAR16 *StrPtr;
CHAR16 TemStr[5];
UINT8 *DataBuffer;
UINT8 DigitUint8;
UINTN Index;
CHAR16 *StrBuffer;
if (Configuration == NULL || Progress == NULL) {
return EFI_INVALID_PARAMETER;
}
PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
HiiConfigRouting = PrivateData->HiiConfigRouting;
*Progress = Configuration;
//
// Check routing data in <ConfigHdr>.
// Note: if only one Storage is used, then this checking could be skipped.
//
if (!HiiIsConfigHdrMatch (Configuration, &gDriverSampleFormSetGuid, 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(Configuration, &gDriverSampleFormSetGuid, MyEfiVar)) {
return EFI_UNSUPPORTED;
}
if (HiiIsConfigHdrMatch(Configuration, &gDriverSampleFormSetGuid, MyEfiBitVar)) {
return EFI_UNSUPPORTED;
}
if (HiiIsConfigHdrMatch(Configuration, &gDriverSampleFormSetGuid, MyEfiUnionVar)) {
return EFI_UNSUPPORTED;
}
//
// Get Buffer Storage data from EFI variable
//
BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
Status = gRT->GetVariable (
VariableName,
&gDriverSampleFormSetGuid,
NULL,
&BufferSize,
&PrivateData->Configuration
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Check if configuring Name/Value storage
//
if (StrStr (Configuration, L"OFFSET") == NULL) {
//
// Update Name/Value storage Names
//
Status = LoadNameValueNames (PrivateData);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Convert value for NameValueVar0
//
if ((Value = StrStr (Configuration, PrivateData->NameValueName[0])) != NULL) {
//
// Skip "Name="
//
Value += StrLen (PrivateData->NameValueName[0]);
Value++;
//
// Get Value String
//
StrPtr = StrStr (Value, L"&");
if (StrPtr == NULL) {
StrPtr = Value + StrLen (Value);
}
//
// Convert Value to Buffer data
//
DataBuffer = (UINT8 *) &PrivateData->Configuration.NameValueVar0;
ZeroMem (TemStr, sizeof (TemStr));
for (Index = 0, StrPtr --; StrPtr >= Value; StrPtr --, Index ++) {
TemStr[0] = *StrPtr;
DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
if ((Index & 1) == 0) {
DataBuffer [Index/2] = DigitUint8;
} else {
DataBuffer [Index/2] = (UINT8) ((UINT8) (DigitUint8 << 4) + DataBuffer [Index/2]);
}
}
}
//
// Convert value for NameValueVar1
//
if ((Value = StrStr (Configuration, PrivateData->NameValueName[1])) != NULL) {
//
// Skip "Name="
//
Value += StrLen (PrivateData->NameValueName[1]);
Value++;
//
// Get Value String
//
StrPtr = StrStr (Value, L"&");
if (StrPtr == NULL) {
StrPtr = Value + StrLen (Value);
}
//
// Convert Value to Buffer data
//
DataBuffer = (UINT8 *) &PrivateData->Configuration.NameValueVar1;
ZeroMem (TemStr, sizeof (TemStr));
for (Index = 0, StrPtr --; StrPtr >= Value; StrPtr --, Index ++) {
TemStr[0] = *StrPtr;
DigitUint8 = (UINT8) StrHexToUint64 (TemStr);
if ((Index & 1) == 0) {
DataBuffer [Index/2] = DigitUint8;
} else {
DataBuffer [Index/2] = (UINT8) ((UINT8) (DigitUint8 << 4) + DataBuffer [Index/2]);
}
}
}
//
// Convert value for NameValueVar2
//
if ((Value = StrStr (Configuration, PrivateData->NameValueName[2])) != NULL) {
//
// Skip "Name="
//
Value += StrLen (PrivateData->NameValueName[2]);
Value++;
//
// Get Value String
//
StrPtr = StrStr (Value, L"&");
if (StrPtr == NULL) {
StrPtr = Value + StrLen (Value);
}
//
// Convert Config String to Unicode String, e.g "0041004200430044" => "ABCD"
//
StrBuffer = (CHAR16 *) PrivateData->Configuration.NameValueVar2;
ZeroMem (TemStr, sizeof (TemStr));
while (Value < StrPtr) {
StrnCpyS (TemStr, sizeof (TemStr) / sizeof (CHAR16), Value, 4);
*(StrBuffer++) = (CHAR16) StrHexToUint64 (TemStr);
Value += 4;
}
*StrBuffer = L'\0';
}
//
// Store Buffer Storage back to EFI variable
//
Status = gRT->SetVariable(
VariableName,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
&PrivateData->Configuration
);
return Status;
}
//
// Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
//
BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
Status = HiiConfigRouting->ConfigToBlock (
HiiConfigRouting,
Configuration,
(UINT8 *) &PrivateData->Configuration,
&BufferSize,
Progress
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Store Buffer Storage back to EFI variable
//
Status = gRT->SetVariable(
VariableName,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
&PrivateData->Configuration
);
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
)
{
DRIVER_SAMPLE_PRIVATE_DATA *PrivateData;
EFI_STATUS Status;
VOID *StartOpCodeHandle;
VOID *OptionsOpCodeHandle;
EFI_IFR_GUID_LABEL *StartLabel;
VOID *EndOpCodeHandle;
EFI_IFR_GUID_LABEL *EndLabel;
EFI_INPUT_KEY Key;
DRIVER_SAMPLE_CONFIGURATION *Configuration;
MY_EFI_VARSTORE_DATA *EfiData;
EFI_FORM_ID FormId;
EFI_STRING Progress;
EFI_STRING Results;
UINT32 ProgressErr;
CHAR16 *TmpStr;
UINTN Index;
UINT64 BufferValue;
EFI_HII_POPUP_SELECTION UserSelection;
UserSelection = 0xFF;
if (((Value == NULL) && (Action != EFI_BROWSER_ACTION_FORM_OPEN) && (Action != EFI_BROWSER_ACTION_FORM_CLOSE))||
(ActionRequest == NULL)) {
return EFI_INVALID_PARAMETER;
}
FormId = 0;
ProgressErr = 0;
Status = EFI_SUCCESS;
BufferValue = 3;
PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
switch (Action) {
case EFI_BROWSER_ACTION_FORM_OPEN:
{
if (QuestionId == 0x1234) {
//
// Sample CallBack for UEFI FORM_OPEN action:
// Add Save action into Form 3 when Form 1 is opened.
// This will be done only in FORM_OPEN CallBack of question with ID 0x1234 from Form 1.
//
PrivateData = DRIVER_SAMPLE_PRIVATE_FROM_THIS (This);
//
// Initialize the container for dynamic opcodes
//
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (StartOpCodeHandle != NULL);
//
// Create Hii Extend Label OpCode as the start opcode
//
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
StartLabel->Number = LABEL_UPDATE2;
HiiCreateActionOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
0x1238, // Question ID
STRING_TOKEN(STR_SAVE_TEXT), // Prompt text
STRING_TOKEN(STR_SAVE_TEXT), // Help text
EFI_IFR_FLAG_CALLBACK, // Question flag
0 // Action String ID
);
HiiUpdateForm (
PrivateData->HiiHandle[0], // HII handle
&gDriverSampleFormSetGuid, // Formset GUID
0x3, // Form ID
StartOpCodeHandle, // Label for where to insert opcodes
NULL // Insert data
);
HiiFreeOpCodeHandle (StartOpCodeHandle);
}
if (QuestionId == 0x1247) {
Status = InternalStartMonitor ();
ASSERT_EFI_ERROR(Status);
}
}
break;
case EFI_BROWSER_ACTION_FORM_CLOSE:
{
if (QuestionId == 0x5678) {
//
// Sample CallBack for UEFI FORM_CLOSE action:
// Show up a pop-up to specify Form 3 will be closed when exit Form 3.
//
do {
CreatePopUp (
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
&Key,
L"",
L"You are going to leave third Form!",
L"Press ESC or ENTER to continue ...",
L"",
NULL
);
} while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
}
if (QuestionId == 0x1247) {
Status = InternalStopMonitor ();
ASSERT_EFI_ERROR(Status);
}
}
break;
case EFI_BROWSER_ACTION_RETRIEVE:
{
switch (QuestionId ) {
case 0x1248:
if (Type != EFI_IFR_TYPE_REF) {
return EFI_INVALID_PARAMETER;
}
Value->ref.FormId = 0x3;
break;
case 0x5678:
case 0x1247:
//
// We will reach here once the Question is refreshed
//
//
// Initialize the container for dynamic opcodes
//
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (StartOpCodeHandle != NULL);
//
// Create Hii Extend Label OpCode as the start opcode
//
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
if (QuestionId == 0x5678) {
StartLabel->Number = LABEL_UPDATE2;
FormId = 0x03;
PrivateData->Configuration.DynamicRefresh++;
} else if (QuestionId == 0x1247 ) {
StartLabel->Number = LABEL_UPDATE3;
FormId = 0x06;
PrivateData->Configuration.RefreshGuidCount++;
}
HiiCreateActionOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
0x1237, // Question ID
STRING_TOKEN(STR_EXIT_TEXT), // Prompt text
STRING_TOKEN(STR_EXIT_TEXT), // Help text
EFI_IFR_FLAG_CALLBACK, // Question flag
0 // Action String ID
);
HiiUpdateForm (
PrivateData->HiiHandle[0], // HII handle
&gDriverSampleFormSetGuid, // Formset GUID
FormId, // Form ID
StartOpCodeHandle, // Label for where to insert opcodes
NULL // Insert data
);
HiiFreeOpCodeHandle (StartOpCodeHandle);
//
// Refresh the Question value
//
Status = gRT->SetVariable(
VariableName,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
&PrivateData->Configuration
);
if (QuestionId == 0x5678) {
//
// Update uncommitted data of Browser
//
EfiData = AllocateZeroPool (sizeof (MY_EFI_VARSTORE_DATA));
ASSERT (EfiData != NULL);
if (HiiGetBrowserData (&gDriverSampleFormSetGuid, MyEfiVar, sizeof (MY_EFI_VARSTORE_DATA), (UINT8 *) EfiData)) {
EfiData->Field8 = 111;
HiiSetBrowserData (
&gDriverSampleFormSetGuid,
MyEfiVar,
sizeof (MY_EFI_VARSTORE_DATA),
(UINT8 *) EfiData,
NULL
);
}
FreePool(EfiData);
}
break;
}
}
break;
case EFI_BROWSER_ACTION_DEFAULT_STANDARD:
{
switch (QuestionId) {
case 0x1240:
Value->u8 = DEFAULT_CLASS_STANDARD_VALUE;
break;
case 0x1252:
for (Index = 0; Index < 3; Index ++) {
SetArrayData (Value, EFI_IFR_TYPE_NUM_SIZE_8, Index, BufferValue--);
}
break;
case 0x6666:
Value->u8 = 12;
break;
default:
Status = EFI_UNSUPPORTED;
break;
}
}
break;
case EFI_BROWSER_ACTION_DEFAULT_MANUFACTURING:
{
switch (QuestionId) {
case 0x1240:
Value->u8 = DEFAULT_CLASS_MANUFACTURING_VALUE;
break;
case 0x6666:
Value->u8 = 13;
break;
default:
Status = EFI_UNSUPPORTED;
break;
}
}
break;
case EFI_BROWSER_ACTION_CHANGING:
{
switch (QuestionId) {
case 0x1249:
{
if (Type != EFI_IFR_TYPE_REF) {
return EFI_INVALID_PARAMETER;
}
Value->ref.FormId = 0x1234;
}
break;
case 0x1234:
//
// Initialize the container for dynamic opcodes
//
StartOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (StartOpCodeHandle != NULL);
EndOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (EndOpCodeHandle != NULL);
//
// Create Hii Extend Label OpCode as the start opcode
//
StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
StartLabel->Number = LABEL_UPDATE1;
//
// Create Hii Extend Label OpCode as the end opcode
//
EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
EndLabel->Number = LABEL_END;
HiiCreateActionOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
0x1237, // Question ID
STRING_TOKEN(STR_EXIT_TEXT), // Prompt text
STRING_TOKEN(STR_EXIT_TEXT), // Help text
EFI_IFR_FLAG_CALLBACK, // Question flag
0 // Action String ID
);
//
// Create Option OpCode
//
OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
ASSERT (OptionsOpCodeHandle != NULL);
HiiCreateOneOfOptionOpCode (
OptionsOpCodeHandle,
STRING_TOKEN (STR_BOOT_OPTION1),
0,
EFI_IFR_NUMERIC_SIZE_1,
1
);
HiiCreateOneOfOptionOpCode (
OptionsOpCodeHandle,
STRING_TOKEN (STR_BOOT_OPTION2),
0,
EFI_IFR_NUMERIC_SIZE_1,
2
);
//
// Prepare initial value for the dynamic created oneof Question
//
PrivateData->Configuration.DynamicOneof = 2;
Status = gRT->SetVariable(
VariableName,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
&PrivateData->Configuration
);
//
// Set initial vlaue of dynamic created oneof Question in Form Browser
//
Configuration = AllocateZeroPool (sizeof (DRIVER_SAMPLE_CONFIGURATION));
ASSERT (Configuration != NULL);
if (HiiGetBrowserData (&gDriverSampleFormSetGuid, VariableName, sizeof (DRIVER_SAMPLE_CONFIGURATION), (UINT8 *) Configuration)) {
Configuration->DynamicOneof = 2;
//
// Update uncommitted data of Browser
//
HiiSetBrowserData (
&gDriverSampleFormSetGuid,
VariableName,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
(UINT8 *) Configuration,
NULL
);
}
FreePool(Configuration);
HiiCreateOneOfOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
0x8001, // Question ID (or call it "key")
CONFIGURATION_VARSTORE_ID, // VarStore ID
(UINT16) DYNAMIC_ONE_OF_VAR_OFFSET, // Offset in Buffer Storage
STRING_TOKEN (STR_ONE_OF_PROMPT), // Question prompt text
STRING_TOKEN (STR_ONE_OF_HELP), // Question help text
EFI_IFR_FLAG_CALLBACK, // Question flag
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question Value
OptionsOpCodeHandle, // Option Opcode list
NULL // Default Opcode is NULl
);
HiiCreateOrderedListOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
0x8002, // Question ID
CONFIGURATION_VARSTORE_ID, // VarStore ID
(UINT16) DYNAMIC_ORDERED_LIST_VAR_OFFSET, // Offset in Buffer Storage
STRING_TOKEN (STR_BOOT_OPTIONS), // Question prompt text
STRING_TOKEN (STR_BOOT_OPTIONS), // Question help text
EFI_IFR_FLAG_RESET_REQUIRED, // Question flag
0, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
EFI_IFR_NUMERIC_SIZE_1, // Data type of Question value
5, // Maximum container
OptionsOpCodeHandle, // Option Opcode list
NULL // Default Opcode is NULl
);
HiiCreateTextOpCode (
StartOpCodeHandle,
STRING_TOKEN(STR_TEXT_SAMPLE_HELP),
STRING_TOKEN(STR_TEXT_SAMPLE_HELP),
STRING_TOKEN(STR_TEXT_SAMPLE_STRING)
);
HiiCreateDateOpCode (
StartOpCodeHandle,
0x8004,
0x0,
0x0,
STRING_TOKEN(STR_DATE_SAMPLE_HELP),
STRING_TOKEN(STR_DATE_SAMPLE_HELP),
0,
QF_DATE_STORAGE_TIME,
NULL
);
HiiCreateTimeOpCode (
StartOpCodeHandle,
0x8005,
0x0,
0x0,
STRING_TOKEN(STR_TIME_SAMPLE_HELP),
STRING_TOKEN(STR_TIME_SAMPLE_HELP),
0,
QF_TIME_STORAGE_TIME,
NULL
);
HiiCreateGotoOpCode (
StartOpCodeHandle, // Container for dynamic created opcodes
1, // Target Form ID
STRING_TOKEN (STR_GOTO_FORM1), // Prompt text
STRING_TOKEN (STR_GOTO_HELP), // Help text
0, // Question flag
0x8003 // Question ID
);
HiiUpdateForm (
PrivateData->HiiHandle[0], // HII handle
&gDriverSampleFormSetGuid, // Formset GUID
0x1234, // Form ID
StartOpCodeHandle, // Label for where to insert opcodes
EndOpCodeHandle // Replace data
);
HiiFreeOpCodeHandle (StartOpCodeHandle);
HiiFreeOpCodeHandle (OptionsOpCodeHandle);
HiiFreeOpCodeHandle (EndOpCodeHandle);
break;
default:
break;
}
}
break;
case EFI_BROWSER_ACTION_CHANGED:
switch (QuestionId) {
case 0x1237:
//
// User press "Exit now", request Browser to exit
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
break;
case 0x1238:
//
// User press "Save now", request Browser to save the uncommitted data.
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
break;
case 0x1241:
case 0x1246:
//
// User press "Submit current form and Exit now", request Browser to submit current form and exit
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;
break;
case 0x1242:
//
// User press "Discard current form now", request Browser to discard the uncommitted data.
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD;
break;
case 0x1243:
//
// User press "Submit current form now", request Browser to save the uncommitted data.
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;
break;
case 0x1244:
case 0x1245:
//
// User press "Discard current form and Exit now", request Browser to discard the uncommitted data and exit.
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_DISCARD_EXIT;
break;
case 0x1231:
//
// 1. Check to see whether system support keyword.
//
Status = PrivateData->HiiKeywordHandler->GetData (PrivateData->HiiKeywordHandler,
L"NAMESPACE=x-UEFI-ns",
L"KEYWORD=iSCSIBootEnable",
&Progress,
&ProgressErr,
&Results
);
if (EFI_ERROR(Status)) {
do {
CreatePopUp (
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
&Key,
L"",
L"This system not support this keyword!",
L"Press ENTER to continue ...",
L"",
NULL
);
} while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
Status = EFI_SUCCESS;
break;
}
//
// 2. If system support this keyword, just try to change value.
//
//
// Change value from '0' to '1' or from '1' to '0'
//
TmpStr = StrStr (Results, L"&VALUE=");
ASSERT (TmpStr != NULL);
TmpStr += StrLen (L"&VALUE=");
TmpStr++;
if (*TmpStr == L'0') {
*TmpStr = L'1';
} else {
*TmpStr = L'0';
}
//
// 3. Call the keyword handler protocol to change the value.
//
Status = PrivateData->HiiKeywordHandler->SetData (PrivateData->HiiKeywordHandler,
Results,
&Progress,
&ProgressErr
);
if (EFI_ERROR(Status)) {
do {
CreatePopUp (
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
&Key,
L"",
L"Set keyword to the system failed!",
L"Press ENTER to continue ...",
L"",
NULL
);
} while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
Status = EFI_SUCCESS;
break;
}
break;
case 0x1330:
Status = mPrivateData->HiiPopup->CreatePopup (
mPrivateData->HiiPopup,
EfiHiiPopupStyleInfo,
EfiHiiPopupTypeYesNo,
mPrivateData->HiiHandle[0],
STRING_TOKEN (STR_POPUP_STRING),
&UserSelection
);
if (!EFI_ERROR(Status)) {
if (UserSelection == EfiHiiPopupSelectionYes) {
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
}
}
break;
default:
break;
}
break;
case EFI_BROWSER_ACTION_SUBMITTED:
{
if (QuestionId == 0x1250) {
//
// Sample CallBack for EFI_BROWSER_ACTION_SUBMITTED action:
// Show up a pop-up to show SUBMITTED callback has been triggered.
//
do {
CreatePopUp (
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
&Key,
L"",
L"EfiVarstore value has been submitted!",
L"Press ESC or ENTER to continue ...",
L"",
NULL
);
} while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
}
}
break;
default:
Status = EFI_UNSUPPORTED;
break;
}
return Status;
}
/**
Main entry for this driver.
@param ImageHandle Image handle this driver.
@param SystemTable Pointer to SystemTable.
@retval EFI_SUCESS This function always complete successfully.
**/
EFI_STATUS
EFIAPI
DriverSampleInit (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_HII_HANDLE HiiHandle[2];
EFI_SCREEN_DESCRIPTOR Screen;
EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
EFI_HII_STRING_PROTOCOL *HiiString;
EFI_FORM_BROWSER2_PROTOCOL *FormBrowser2;
EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
EFI_CONFIG_KEYWORD_HANDLER_PROTOCOL *HiiKeywordHandler;
EFI_HII_POPUP_PROTOCOL *PopupHandler;
CHAR16 *NewString;
UINTN BufferSize;
DRIVER_SAMPLE_CONFIGURATION *Configuration;
BOOLEAN ActionFlag;
EFI_STRING ConfigRequestHdr;
EFI_STRING NameRequestHdr;
MY_EFI_VARSTORE_DATA *VarStoreConfig;
MY_EFI_BITS_VARSTORE_DATA *BitsVarStoreConfig;
MY_EFI_UNION_DATA *UnionConfig;
EFI_INPUT_KEY HotKey;
EDKII_FORM_BROWSER_EXTENSION_PROTOCOL *FormBrowserEx;
//
// Initialize the local variables.
//
ConfigRequestHdr = NULL;
NewString = NULL;
//
// Initialize screen dimensions for SendForm().
// Remove 3 characters from top and bottom
//
ZeroMem (&Screen, sizeof (EFI_SCREEN_DESCRIPTOR));
gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Screen.RightColumn, &Screen.BottomRow);
Screen.TopRow = 3;
Screen.BottomRow = Screen.BottomRow - 3;
//
// Initialize driver private data
//
mPrivateData = AllocateZeroPool (sizeof (DRIVER_SAMPLE_PRIVATE_DATA));
if (mPrivateData == NULL) {
return EFI_OUT_OF_RESOURCES;
}
mPrivateData->Signature = DRIVER_SAMPLE_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 Formbrowser2 protocol
//
Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &FormBrowser2);
if (EFI_ERROR(Status)) {
return Status;
}
mPrivateData->FormBrowser2 = FormBrowser2;
//
// Locate ConfigRouting protocol
//
Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &HiiConfigRouting);
if (EFI_ERROR(Status)) {
return Status;
}
mPrivateData->HiiConfigRouting = HiiConfigRouting;
//
// Locate keyword handler protocol
//
Status = gBS->LocateProtocol (&gEfiConfigKeywordHandlerProtocolGuid, NULL, (VOID **) &HiiKeywordHandler);
if (EFI_ERROR(Status)) {
return Status;
}
mPrivateData->HiiKeywordHandler = HiiKeywordHandler;
//
// Locate HiiPopup protocol
//
Status = gBS->LocateProtocol (&gEfiHiiPopupProtocolGuid, NULL, (VOID **) &PopupHandler);
if (EFI_ERROR(Status)) {
return Status;
}
mPrivateData->HiiPopup = PopupHandler;
Status = gBS->InstallMultipleProtocolInterfaces (
&DriverHandle[0],
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath0,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
ASSERT_EFI_ERROR(Status);
mPrivateData->DriverHandle[0] = DriverHandle[0];
//
// Publish our HII data
//
HiiHandle[0] = HiiAddPackages (
&gDriverSampleFormSetGuid,
DriverHandle[0],
DriverSampleStrings,
VfrBin,
NULL
);
if (HiiHandle[0] == NULL) {
return EFI_OUT_OF_RESOURCES;
}
mPrivateData->HiiHandle[0] = HiiHandle[0];
//
// Publish another Fromset
//
Status = gBS->InstallMultipleProtocolInterfaces (
&DriverHandle[1],
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath1,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
ASSERT_EFI_ERROR(Status);
mPrivateData->DriverHandle[1] = DriverHandle[1];
HiiHandle[1] = HiiAddPackages (
&gDriverSampleInventoryGuid,
DriverHandle[1],
DriverSampleStrings,
InventoryBin,
NULL
);
if (HiiHandle[1] == NULL) {
DriverSampleUnload (ImageHandle);
return EFI_OUT_OF_RESOURCES;
}
mPrivateData->HiiHandle[1] = HiiHandle[1];
//
// Update the device path string.
//
NewString = ConvertDevicePathToText((EFI_DEVICE_PATH_PROTOCOL*)&mHiiVendorDevicePath0, FALSE, FALSE);
if (HiiSetString (HiiHandle[0], STRING_TOKEN (STR_DEVICE_PATH), NewString, NULL) == 0) {
DriverSampleUnload (ImageHandle);
return EFI_OUT_OF_RESOURCES;
}
if (NewString != NULL) {
FreePool(NewString);
}
//
// Very simple example of how one would update a string that is already
// in the HII database
//
NewString = L"700 Mhz";
if (HiiSetString (HiiHandle[0], STRING_TOKEN (STR_CPU_STRING2), NewString, NULL) == 0) {
DriverSampleUnload (ImageHandle);
return EFI_OUT_OF_RESOURCES;
}
HiiSetString (HiiHandle[0], 0, NewString, NULL);
//
// Initialize Name/Value name String ID
//
mPrivateData->NameStringId[0] = STR_NAME_VALUE_VAR_NAME0;
mPrivateData->NameStringId[1] = STR_NAME_VALUE_VAR_NAME1;
mPrivateData->NameStringId[2] = STR_NAME_VALUE_VAR_NAME2;
//
// Initialize configuration data
//
Configuration = &mPrivateData->Configuration;
ZeroMem (Configuration, sizeof (DRIVER_SAMPLE_CONFIGURATION));
//
// Try to read NV config EFI variable first
//
ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, VariableName, DriverHandle[0]);
ASSERT (ConfigRequestHdr != NULL);
NameRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, NULL, DriverHandle[0]);
ASSERT (NameRequestHdr != NULL);
BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
Status = gRT->GetVariable (VariableName, &gDriverSampleFormSetGuid, NULL, &BufferSize, Configuration);
if (EFI_ERROR(Status)) {
//
// Store zero data Buffer Storage to EFI variable
//
Status = gRT->SetVariable(
VariableName,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (DRIVER_SAMPLE_CONFIGURATION),
Configuration
);
if (EFI_ERROR(Status)) {
DriverSampleUnload (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 (NameRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
ActionFlag = HiiSetToDefaults (ConfigRequestHdr, EFI_HII_DEFAULT_CLASS_STANDARD);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
} else {
//
// EFI variable does exist and Validate Current Setting
//
ActionFlag = HiiValidateSettings (NameRequestHdr);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
ActionFlag = HiiValidateSettings (ConfigRequestHdr);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
}
FreePool(ConfigRequestHdr);
//
// Initialize efi varstore configuration data
//
VarStoreConfig = &mPrivateData->VarStoreConfig;
ZeroMem (VarStoreConfig, sizeof (MY_EFI_VARSTORE_DATA));
ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, MyEfiVar, DriverHandle[0]);
ASSERT (ConfigRequestHdr != NULL);
BufferSize = sizeof (MY_EFI_VARSTORE_DATA);
Status = gRT->GetVariable (MyEfiVar, &gDriverSampleFormSetGuid, NULL, &BufferSize, VarStoreConfig);
if (EFI_ERROR(Status)) {
//
// Store zero data to EFI variable Storage.
//
Status = gRT->SetVariable(
MyEfiVar,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (MY_EFI_VARSTORE_DATA),
VarStoreConfig
);
if (EFI_ERROR(Status)) {
DriverSampleUnload (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) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
} else {
//
// EFI variable does exist and Validate Current Setting
//
ActionFlag = HiiValidateSettings (ConfigRequestHdr);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
}
FreePool(ConfigRequestHdr);
//
// Initialize Bits efi varstore configuration data
//
BitsVarStoreConfig = &mPrivateData->BitsVarStoreConfig;
ZeroMem (BitsVarStoreConfig, sizeof (MY_EFI_BITS_VARSTORE_DATA));
ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, MyEfiBitVar, DriverHandle[0]);
ASSERT (ConfigRequestHdr != NULL);
BufferSize = sizeof (MY_EFI_BITS_VARSTORE_DATA);
Status = gRT->GetVariable (MyEfiBitVar, &gDriverSampleFormSetGuid, NULL, &BufferSize, BitsVarStoreConfig);
if (EFI_ERROR(Status)) {
//
// Store zero data to EFI variable Storage.
//
Status = gRT->SetVariable(
MyEfiBitVar,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (MY_EFI_BITS_VARSTORE_DATA),
BitsVarStoreConfig
);
if (EFI_ERROR(Status)) {
DriverSampleUnload (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) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
} else {
//
// EFI variable does exist and Validate Current Setting
//
ActionFlag = HiiValidateSettings (ConfigRequestHdr);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
}
FreePool(ConfigRequestHdr);
//
// Initialize Union efi varstore configuration data
//
UnionConfig = &mPrivateData->UnionConfig;
ZeroMem (UnionConfig, sizeof (MY_EFI_UNION_DATA));
ConfigRequestHdr = HiiConstructConfigHdr (&gDriverSampleFormSetGuid, MyEfiUnionVar, DriverHandle[0]);
ASSERT (ConfigRequestHdr != NULL);
BufferSize = sizeof (MY_EFI_UNION_DATA);
Status = gRT->GetVariable (MyEfiUnionVar, &gDriverSampleFormSetGuid, NULL, &BufferSize, UnionConfig);
if (EFI_ERROR(Status)) {
//
// Store zero data to EFI variable Storage.
//
Status = gRT->SetVariable(
MyEfiUnionVar,
&gDriverSampleFormSetGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (MY_EFI_UNION_DATA),
UnionConfig
);
if (EFI_ERROR(Status)) {
DriverSampleUnload (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) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
} else {
//
// EFI variable does exist and Validate Current Setting
//
ActionFlag = HiiValidateSettings (ConfigRequestHdr);
if (!ActionFlag) {
DriverSampleUnload (ImageHandle);
return EFI_INVALID_PARAMETER;
}
}
FreePool(ConfigRequestHdr);
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
EfiEventEmptyFunction,
NULL,
&gEfiIfrRefreshIdOpGuid,
&mEvent
);
ASSERT_EFI_ERROR(Status);
//
// Example of how to use BrowserEx protocol to register HotKey.
//
Status = gBS->LocateProtocol (&gEdkiiFormBrowserExProtocolGuid, NULL, (VOID **) &FormBrowserEx);
if (!EFI_ERROR(Status)) {
//
// First unregister the default hot key F9 and F10.
//
HotKey.UnicodeChar = CHAR_NULL;
HotKey.ScanCode = SCAN_F9;
FormBrowserEx->RegisterHotKey (&HotKey, 0, 0, NULL);
HotKey.ScanCode = SCAN_F10;
FormBrowserEx->RegisterHotKey (&HotKey, 0, 0, NULL);
//
// Register the default HotKey F9 and F10 again.
//
HotKey.ScanCode = SCAN_F10;
NewString = HiiGetString (mPrivateData->HiiHandle[0], STRING_TOKEN (FUNCTION_TEN_STRING), NULL);
ASSERT (NewString != NULL);
FormBrowserEx->RegisterHotKey (&HotKey, BROWSER_ACTION_SUBMIT, 0, NewString);
HotKey.ScanCode = SCAN_F9;
NewString = HiiGetString (mPrivateData->HiiHandle[0], STRING_TOKEN (FUNCTION_NINE_STRING), NULL);
ASSERT (NewString != NULL);
FormBrowserEx->RegisterHotKey (&HotKey, BROWSER_ACTION_DEFAULT, EFI_HII_DEFAULT_CLASS_STANDARD, NewString);
}
//
// In default, this driver is built into Flash device image,
// the following code doesn't run.
//
//
// Example of how to display only the item we sent to HII
// When this driver is not built into Flash device image,
// it need to call SendForm to show front page by itself.
//
if (DISPLAY_ONLY_MY_ITEM <= 1) {
//
// Have the browser pull out our copy of the data, and only display our data
//
Status = FormBrowser2->SendForm (
FormBrowser2,
&(HiiHandle[DISPLAY_ONLY_MY_ITEM]),
1,
NULL,
0,
NULL,
NULL
);
HiiRemovePackages (HiiHandle[0]);
HiiRemovePackages (HiiHandle[1]);
}
return EFI_SUCCESS;
}
/**
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
DriverSampleUnload (
IN EFI_HANDLE ImageHandle
)
{
UINTN Index;
ASSERT (mPrivateData != NULL);
if (DriverHandle[0] != NULL) {
gBS->UninstallMultipleProtocolInterfaces (
DriverHandle[0],
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath0,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
DriverHandle[0] = NULL;
}
if (DriverHandle[1] != NULL) {
gBS->UninstallMultipleProtocolInterfaces (
DriverHandle[1],
&gEfiDevicePathProtocolGuid,
&mHiiVendorDevicePath1,
&gEfiHiiConfigAccessProtocolGuid,
&mPrivateData->ConfigAccess,
NULL
);
DriverHandle[1] = NULL;
}
if (mPrivateData->HiiHandle[0] != NULL) {
HiiRemovePackages (mPrivateData->HiiHandle[0]);
}
if (mPrivateData->HiiHandle[1] != NULL) {
HiiRemovePackages (mPrivateData->HiiHandle[1]);
}
for (Index = 0; Index < NAME_VALUE_NAME_NUMBER; Index++) {
if (mPrivateData->NameValueName[Index] != NULL) {
FreePool(mPrivateData->NameValueName[Index]);
}
}
FreePool(mPrivateData);
mPrivateData = NULL;
gBS->CloseEvent (mEvent);
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink