xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeSetupPkg/Library/H2ODisplayEngineLib/H2ODisplayEngineLib.c

1560 lines
44 KiB
C
Raw Blame History

/** @file
Implement H2O display engine related functions.
;******************************************************************************
;* Copyright (c) 2015 - 2020, 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 "H2ODisplayEngineLibInternal.h"
#include <Library/DxeOemSvcKernelLib.h>
#include <Guid/ZeroGuid.h>
/**
Check if the input character is a decimal character
@param[in] UnicodeChar Unicode character
@retval TRUE The input character is a decimal character
@retval FALSE The input character is not a decimal character
**/
BOOLEAN
IsDecChar (
IN CHAR16 UnicodeChar
)
{
return (BOOLEAN) (UnicodeChar >= '0' && UnicodeChar <= '9');
}
/**
Check if the input character is a hexadecimal character
@param[in] UnicodeChar Unicode character
@retval TRUE The input character is a hexadecimal character
@retval FALSE The input character is not a hexadecimal character
**/
BOOLEAN
IsHexChar (
IN CHAR16 UnicodeChar
)
{
if ((UnicodeChar >= '0' && UnicodeChar <= '9') ||
(UnicodeChar >= 'a' && UnicodeChar <= 'f') ||
(UnicodeChar >= 'A' && UnicodeChar <= 'F')) {
return TRUE;
}
return FALSE;
}
/**
Check if the input character is a visible character
@param[in] UnicodeChar Unicode character
@retval TRUE The input character is a visible character
@retval FALSE The input character is not a visible character
**/
BOOLEAN
IsVisibleChar (
IN CHAR16 UnicodeChar
)
{
return (BOOLEAN) (UnicodeChar >= ' ' && UnicodeChar <= '~');
}
/**
Check if the input string is a hexadecimal string
@param[in] Str Unicode string
@retval TRUE The input string is a hexadecimal string
@retval FALSE The input string is not a hexadecimal string
**/
BOOLEAN
IsHexString (
IN CHAR16 *Str
)
{
//
// skip preceeding white space
//
while ((*Str != 0) && *Str == L' ') {
Str++;
}
//
// skip preceeding zeros
//
while ((*Str != 0) && *Str == L'0') {
Str++;
}
return (BOOLEAN) (*Str == L'x' || *Str == L'X');
}
/**
Check if the input year value is leap year
@param[in] Year Year value
@retval TRUE The input year value is leap year
@retval FALSE The input year value is not leap year
**/
BOOLEAN
IsLeapYear (
IN UINT16 Year
)
{
return (BOOLEAN) ((Year%4 == 0) && ((Year%100 != 0) || (Year%400 == 0)));
}
/**
Check if the input time is valid
@param[in] EfiTime Pointer to EFI time
@retval TRUE The input time is valid
@retval FALSE The input time is not valid
**/
BOOLEAN
IsTimeValid (
IN EFI_TIME *EfiTime
)
{
if (EfiTime == NULL || (EfiTime->Hour > 23) || (EfiTime->Minute > 59) || (EfiTime->Second > 59)) {
return FALSE;
}
return TRUE;
}
/**
Check if the input day is valid
@param[in] EfiTime Pointer to EFI time
@retval TRUE The input day is valid
@retval FALSE The input day is not valid
**/
BOOLEAN
IsDayValid (
IN EFI_TIME *EfiTime
)
{
UINT8 DayOfMonth[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (EfiTime == NULL ||
(EfiTime->Day < 1) ||
(EfiTime->Month < 1) ||
(EfiTime->Month > 12) ||
(EfiTime->Day > DayOfMonth[EfiTime->Month - 1]) ||
(EfiTime->Month == 2 && (!IsLeapYear (EfiTime->Year) && EfiTime->Day > 28)) ||
(EfiTime->Year < PcdGet16 (PcdRealTimeClockYearMin) || EfiTime->Year > PcdGet16 (PcdRealTimeClockYearMax))) {
return FALSE;
}
return TRUE;
}
/**
Check if current page is root page
@retval TRUE The current page is root page
@retval FALSE The current page is not root page, fail to locate protocol, current page pointer is NULL or
fail to get setup menu.
**/
BOOLEAN
IsRootPage (
VOID
)
{
EFI_STATUS Status;
H2O_FORM_BROWSER_PROTOCOL *FBProtocol;
SETUP_MENU_INFO CurrentSetupMenuInfo;
Status = gBS->LocateProtocol (&gH2OFormBrowserProtocolGuid, NULL, (VOID **) &FBProtocol);
if (EFI_ERROR (Status) || FBProtocol->CurrentP == NULL) {
return FALSE;
}
Status = GetSetupMenuInfoByPage (FBProtocol->CurrentP, &CurrentSetupMenuInfo);
if (EFI_ERROR (Status)) {
return FALSE;
}
return (BOOLEAN) (CurrentSetupMenuInfo.PageId == FBProtocol->CurrentP->PageId);
}
/**
Check if the edit value is valid or not.
The valid condition is that the edit value or possible range overlap on [MinValue, MaxValue].
@param[in] EditValue Edit value
@param[in] MinValue Minimum value
@param[in] MaxValue Maximum value
@param[in] IsHex Flag to determine that the edit value is hex
@retval TRUE The edit value is valid
@retval FALSE The edit value is not valid
**/
BOOLEAN
IsEditValueValid (
IN UINT64 EditValue,
IN UINT64 MinValue,
IN UINT64 MaxValue,
IN BOOLEAN IsHex
)
{
UINT32 Base;
UINT64 PossibleRangeMin;
UINT64 PossibleRangeMax;
UINT64 Limit;
//
// First, check if the edit value overlap on [MinValue, MaxValue]
//
if (EditValue == 0 || IN_RANGE (EditValue, MinValue, MaxValue)) {
return TRUE;
}
//
// Second, check if the passible range of edit value overlap on [MinValue, MaxValue]
// Keep possible range be multiplied by base until min value of possible range exceed MaxValue.
// For example: If [MinValue, MaxValue] is [2, 200], possible range will be [10, 19] and [100, 199] when edit value is 1.
//
if (EditValue > MaxValue) {
return FALSE;
}
Base = IsHex ? 16 : 10;
Limit = DivU64x32 ((UINT64) -1, Base);
PossibleRangeMin = EditValue;
PossibleRangeMax = EditValue;
while (PossibleRangeMin <= Limit) {
PossibleRangeMin = MultU64x32 (PossibleRangeMin, Base);
PossibleRangeMax = MultU64x32 (PossibleRangeMax, Base) + (Base - 1);
if (PossibleRangeMin > MaxValue) {
return FALSE;
}
if (IS_OVERLAP (PossibleRangeMin, PossibleRangeMax, MinValue, MaxValue)) {
return TRUE;
}
}
return FALSE;
}
/**
Check if the value string is valid or not.
@param[in] ValueStr Input value string for being checked
@param[in] IsHex Is hex number or not
@retval TRUE The value string is valid
@retval FALSE The value string is invalid
**/
STATIC
BOOLEAN
IsValidValueStr (
IN CHAR16 *ValueStr,
IN BOOLEAN IsHex
)
{
if (ValueStr == NULL) {
return FALSE;
}
while (*ValueStr != CHAR_NULL) {
if ((IsHex && !IsHexChar (*ValueStr)) ||
(!IsHex && !IsDecChar (*ValueStr))) {
return FALSE;
}
ValueStr++;
}
return TRUE;
}
/**
Convert question HII value to INT64 value based on numeric buffer size determined by opcode flag.
@param[in] NumericFlags Numeric opcode flag
@param[in] Value Question HII value
@return Numeric value in INT64 format
**/
STATIC
INT64
IfrNumericConvertValueToInt64 (
IN UINT8 NumericFlags,
IN UINT64 Value
)
{
switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
return (INT64) ((INT8) ((UINT8) Value));
case EFI_IFR_NUMERIC_SIZE_2:
return (INT64) ((INT16) ((UINT16) Value));
case EFI_IFR_NUMERIC_SIZE_4:
return (INT64) ((INT32) ((UINT32) Value));
case EFI_IFR_NUMERIC_SIZE_8:
default:
return (INT64) Value;
}
}
/**
Convert INT64 value to question HII value based on numeric buffer size determined by opcode flag.
@param[in] NumericFlags Numeric opcode flag
@param[in] Int64Value Numeric value in INT64 format
@return Question HII value
**/
STATIC
UINT64
IfrNumericConvertInt64ToValue (
IN UINT8 NumericFlags,
IN INT64 Int64Value
)
{
switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
return (UINT64) ((UINT8) ((INT8) Int64Value));
case EFI_IFR_NUMERIC_SIZE_2:
return (UINT64) ((UINT16) ((INT16) Int64Value));
case EFI_IFR_NUMERIC_SIZE_4:
return (UINT64) ((UINT32) ((INT32) Int64Value));
case EFI_IFR_NUMERIC_SIZE_8:
default:
return (UINT64) Int64Value;
}
}
/**
Convert the numeric string to question HII value.
@param[in] NumericFlags Numeric opcode flags
@param[in] NumericStr Pointer to numeric string
@retval Question HII value in UINT64 format or 0 if input string pointer is NULL.
**/
UINT64
IfrNumericConvertStrToValue (
IN UINT8 NumericFlags,
IN CHAR16 *NumericStr
)
{
UINT64 Value;
if (NumericStr == NULL) {
return 0;
}
while (*NumericStr != CHAR_NULL && *NumericStr == ' ') {
NumericStr++;
}
Value = 0;
switch (NumericFlags & EFI_IFR_DISPLAY) {
case EFI_IFR_DISPLAY_INT_DEC:
if (*NumericStr == '-') {
Value = StrDecimalToUint64 (NumericStr + 1);
switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
Value = (UINT8) -((INT8) Value);
break;
case EFI_IFR_NUMERIC_SIZE_2:
Value = (UINT16) -((INT16) Value);
break;
case EFI_IFR_NUMERIC_SIZE_4:
Value = (UINT32) -((INT32) Value);
break;
case EFI_IFR_NUMERIC_SIZE_8:
Value = (UINT64) -((INT64) Value);
break;
}
} else {
Value = StrDecimalToUint64 (NumericStr);
}
return Value;
case EFI_IFR_DISPLAY_UINT_DEC:
return StrDecimalToUint64 (NumericStr);
case EFI_IFR_DISPLAY_UINT_HEX:
return StrHexToUint64 (NumericStr);
}
return Value;
}
/**
Get numeric value size from numeric question flags.
@param[in] NumericFlags Numeric opcode flags
@return Numeric value size
**/
UINTN
IfrNumericGetValueSize (
IN UINT8 NumericFlags
)
{
switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
return 1;
case EFI_IFR_NUMERIC_SIZE_2:
return 2;
case EFI_IFR_NUMERIC_SIZE_4:
return 4;
case EFI_IFR_NUMERIC_SIZE_8:
default:
return 8;
}
}
/**
Check if the question HII value is in range [Minimum, Maximum] or not.
@param[in] NumericFlags Numeric opcode flags
@param[in] Value Question HII value
@param[in] Minimum Minimum value
@param[in] Maximum Maximum value
@retval TRUE The value is in range
@retval FALSE The value is not in range
**/
BOOLEAN
IfrNumericIsValueInRange (
IN UINT8 NumericFlags,
IN UINT64 Value,
IN UINT64 Minimum,
IN UINT64 Maximum
)
{
if ((NumericFlags & EFI_IFR_DISPLAY) == EFI_IFR_DISPLAY_INT_DEC) {
return IN_RANGE (IfrNumericConvertValueToInt64 (NumericFlags, Value),
IfrNumericConvertValueToInt64 (NumericFlags, Minimum),
IfrNumericConvertValueToInt64 (NumericFlags, Maximum));
} else {
return IN_RANGE (Value, Minimum, Maximum);
}
}
/**
Check if the editing signed decimal string in is valid or not.
@param[in] EditStr Pointer to editing signed decimal string
@param[in] Minimum Minimum value
@param[in] Maximum Maximum value
@retval TRUE The editing string is in valid
@retval FALSE The editing string is not valid
**/
STATIC
BOOLEAN
IfrNumericIsEditSignedDecStrValid (
IN CHAR16 *EditStr,
IN INT64 Minimum,
IN INT64 Maximum
)
{
UINTN ValueStrLen;
CHAR16 ValueStr[22];
BOOLEAN IsNegative;
CHAR16 LastChar;
UINT64 Value;
UINT64 Min;
UINT64 Max;
if (EditStr == NULL) {
return FALSE;
}
//
// Copy string without prefix space, minus char, prefix '0' and suffix space characters.
//
while (*EditStr == ' ') {
EditStr++;
}
if (*EditStr == '-') {
IsNegative = TRUE;
EditStr++;
} else {
IsNegative = FALSE;
}
while (*EditStr == '0') {
EditStr++;
}
for (ValueStrLen = StrLen (EditStr); ValueStrLen > 0 && EditStr[ValueStrLen - 1] == ' '; ValueStrLen--) {
}
if (ValueStrLen > 19) {
return FALSE;
}
StrnCpyS (ValueStr, ARRAY_SIZE(ValueStr), EditStr, ValueStrLen);
if (!IsValidValueStr (ValueStr, FALSE)) {
return FALSE;
}
if (ValueStrLen == 19) {
//
// Because 19 digits value maybe make INT64 overlap
// use 18 digits to check the value whether overlap
//
LastChar = ValueStr[18];
ValueStr[18] = '\0';
Value = StrDecimalToUint64 (ValueStr);
ValueStr[18] = LastChar;
//
// INT64 maximum (minimum) value is 9223372036854775807 (-9223372036854775808).
// If 18 digits is larger than 9223372036854775801ull, user can not input any key.
// If 18 digits is equal to 9223372036854775801ull, user can not input larger than '7' and '8' for positive and negative value
//
if (Value > 922337203685477580ull) {
return FALSE;
}
if ((Value == 922337203685477580ull) &&
((!IsNegative && LastChar > '7') || (IsNegative && LastChar > '8'))) {
return FALSE;
}
}
Value = StrDecimalToUint64 (ValueStr);
if (IsNegative) {
if (Minimum > 0) {
return FALSE;
}
Max = (UINT64) (-Minimum);
Min = (UINT64) ((Maximum > 0) ? 0 : -Maximum);
} else {
if (Maximum < 0) {
return FALSE;
}
Max = (UINT64) (Maximum);
Min = (UINT64) ((Minimum < 0) ? 0 : Minimum);
}
return IsEditValueValid (Value, Min, Max, FALSE);
}
/**
Check if the editing unsigned decimal string in is valid or not.
@param[in] EditStr Pointer to editing unsigned decimal string
@param[in] Minimum Minimum value
@param[in] Maximum Maximum value
@retval TRUE The editing string is in valid
@retval FALSE The editing string is not valid
**/
STATIC
BOOLEAN
IfrNumericIsEditDecStrValid (
IN CHAR16 *EditStr,
IN UINT64 Minimum,
IN UINT64 Maximum
)
{
UINTN ValueStrLen;
CHAR16 ValueStr[22];
CHAR16 LastChar;
UINT64 Value;
if (EditStr == NULL) {
return FALSE;
}
//
// Copy string without prefix space, prefix '0' and suffix space characters.
//
while (*EditStr == ' ' || *EditStr == '0') {
EditStr++;
}
for (ValueStrLen = StrLen (EditStr); ValueStrLen > 0 && EditStr[ValueStrLen - 1] == ' '; ValueStrLen--) {
}
if (ValueStrLen > 20) {
return FALSE;
}
StrnCpyS (ValueStr, ARRAY_SIZE(ValueStr), EditStr, ValueStrLen);
if (!IsValidValueStr (ValueStr, FALSE)) {
return FALSE;
}
if (ValueStrLen == 20) {
//
// Because 20 digits value maybe make UINT64 overlap
// use 19 digits to check the value whether overlap
//
LastChar = ValueStr[19];
ValueStr[19] = '\0';
Value = StrDecimalToUint64 (ValueStr);
ValueStr[19] = LastChar;
//
// UINT64 maximum value is 18446744073709551615.
// If 19 digits is larger than 1844674407370955161ull,
// use can not input any key.
//
if (Value > 1844674407370955161ull) {
return FALSE;
}
//
// UINT64 maximum value is 18446744073709551615.
// If 19 digits is equal to 1844674407370955161ull,
// use can not input larger than '5' key
//
if ((Value == 1844674407370955161ull) && (LastChar > '5')) {
return FALSE;
}
}
Value = StrDecimalToUint64 (ValueStr);
return IsEditValueValid (Value, Minimum, Maximum, FALSE);
}
/**
Check if the editing hex string in is valid or not.
@param[in] EditStr Pointer to editing hex string
@param[in] Minimum Minimum value
@param[in] Maximum Maximum value
@retval TRUE The editing string is in valid
@retval FALSE The editing string is not valid
**/
STATIC
BOOLEAN
IfrNumericIsEditHexStrValid (
IN CHAR16 *EditStr,
IN UINT64 Minimum,
IN UINT64 Maximum
)
{
UINTN ValueStrLen;
CHAR16 ValueStr[22];
UINT64 Value;
if (EditStr == NULL) {
return FALSE;
}
//
// Copy string without prefix space, prefix '0', prefix '0x' and suffix space characters.
//
while (*EditStr == ' ') {
EditStr++;
}
while (EditStr[0] == '0' && EditStr[1] == '0') {
EditStr++;
}
if (EditStr[0] == '0' && (EditStr[1] == 'x' || EditStr[1] == 'X')) {
EditStr += 2;
}
while (*EditStr == '0') {
EditStr++;
}
for (ValueStrLen = StrLen (EditStr); ValueStrLen > 0 && EditStr[ValueStrLen - 1] == ' '; ValueStrLen--) {
}
if (ValueStrLen > 16) {
return FALSE;
}
StrnCpyS (ValueStr, ARRAY_SIZE(ValueStr), EditStr, ValueStrLen);
if (!IsValidValueStr (ValueStr, TRUE)) {
return FALSE;
}
Value = StrHexToUint64 (ValueStr);
return IsEditValueValid (Value, Minimum, Maximum, TRUE);
}
/**
Check if the editing numeric string is valid or not.
@param[in] NumericFlags Numeric opcode flags
@param[in] EditStr Pointer to editing numeric string
@param[in] Minimum Minimum value
@param[in] Maximum Maximum value
@retval TRUE The editing string is in valid
@retval FALSE The editing string is not valid
**/
BOOLEAN
IfrNumericIsEditStrValid (
IN UINT8 NumericFlags,
IN CHAR16 *EditStr,
IN UINT64 Minimum,
IN UINT64 Maximum
)
{
switch (NumericFlags & EFI_IFR_DISPLAY) {
case EFI_IFR_DISPLAY_INT_DEC:
return IfrNumericIsEditSignedDecStrValid (
EditStr,
IfrNumericConvertValueToInt64(NumericFlags, Minimum),
IfrNumericConvertValueToInt64(NumericFlags, Maximum)
);
case EFI_IFR_DISPLAY_UINT_DEC:
return IfrNumericIsEditDecStrValid (EditStr, Minimum, Maximum);
case EFI_IFR_DISPLAY_UINT_HEX:
default:
return IfrNumericIsEditHexStrValid (EditStr, Minimum, Maximum);
}
}
/**
Check if the numeric value string is empty without any value char or not.
@param[in] NumericFlags Numeric opcode flags
@param[in] ValueStr Pointer to numeric value string
@retval TRUE The value string is empty
@retval FALSE The value string is not empty
**/
BOOLEAN
IfrNumericIsEmptyStr (
IN UINT8 NumericFlags,
IN CHAR16 *ValueStr
)
{
CHAR16 *StrPtr;
if (ValueStr == NULL || *ValueStr == CHAR_NULL) {
return TRUE;
}
while (*ValueStr == ' ') {
ValueStr++;
}
switch (NumericFlags & EFI_IFR_DISPLAY) {
case EFI_IFR_DISPLAY_INT_DEC:
if (*ValueStr == '-') {
ValueStr++;
}
break;
case EFI_IFR_DISPLAY_UINT_DEC:
break;
case EFI_IFR_DISPLAY_UINT_HEX:
default:
StrPtr = ValueStr;
while (StrPtr[0] == '0' && StrPtr[1] == '0') {
StrPtr++;
}
if (StrPtr[0] == '0' && (StrPtr[1] == 'x' || StrPtr[1] == 'X')) {
ValueStr = StrPtr + 2;
}
break;
}
return (BOOLEAN) (*ValueStr == CHAR_NULL);
}
/**
Get formatted number string.
@param[in] Question Pointer to H2O form browser question
@retval Formatted number string or NULL if input question pointer is NULL.
**/
CHAR16 *
IfrNumericPrintFormattedNumber (
IN H2O_FORM_BROWSER_Q *Question
)
{
INT64 Value;
if (Question == NULL) {
return NULL;
}
switch (Question->Flags & EFI_IFR_DISPLAY) {
case EFI_IFR_DISPLAY_INT_DEC:
Value = IfrNumericConvertValueToInt64 (Question->Flags, Question->HiiValue.Value.u64);
if (Value < 0) {
Value = -Value;
return CatSPrint (NULL, L"-%lu", Value);
} else {
return CatSPrint (NULL, L"%lu", Value);
}
case EFI_IFR_DISPLAY_UINT_DEC:
return CatSPrint (NULL, L"%lu", Question->HiiValue.Value.u64);
case EFI_IFR_DISPLAY_UINT_HEX:
default:
return CatSPrint (NULL, L"0x%lx", Question->HiiValue.Value.u64);
}
}
/**
Transfer EFI time to EFI HII value
@param[in] IsDate If true, transfer to HII value with date type. Otherwise, transfer to HII value with time type.
@param[in] EfiTime Pointer to EFI time
@param[out] HiiValue Pointer to EFI HII value
@retval EFI_SUCCESS Transfer EFI time to EFI HII value successfully
@retval EFI_INVALID_PARAMETER EfiTime or HiiValue is NULL
**/
EFI_STATUS
TransferEfiTimeToHiiValue (
IN BOOLEAN IsDate,
IN EFI_TIME *EfiTime,
OUT EFI_HII_VALUE *HiiValue
)
{
if (EfiTime == NULL || HiiValue == NULL) {
return EFI_INVALID_PARAMETER;
}
ZeroMem (HiiValue, sizeof(EFI_HII_VALUE));
if (IsDate) {
HiiValue->Type = EFI_IFR_TYPE_DATE;
HiiValue->Value.date.Year = EfiTime->Year;
HiiValue->Value.date.Month = EfiTime->Month;
HiiValue->Value.date.Day = EfiTime->Day;
} else {
HiiValue->Type = EFI_IFR_TYPE_TIME;
HiiValue->Value.time.Hour = EfiTime->Hour;
HiiValue->Value.time.Minute = EfiTime->Minute;
HiiValue->Value.time.Second = EfiTime->Second;
}
return EFI_SUCCESS;
}
/**
Transfer EFI HII value to EFI time
@param[in] HiiValue Pointer to EFI HII value
@param[out] EfiTime Pointer to EFI time
@retval EFI_SUCCESS Transfer EFI HII value to EFI time successfully
@retval EFI_INVALID_PARAMETER EfiTime or HiiValue is NULL or EFI HII value type is not date or time
**/
EFI_STATUS
TransferHiiValueToEfiTime (
IN EFI_HII_VALUE *HiiValue,
OUT EFI_TIME *EfiTime
)
{
if (EfiTime == NULL || HiiValue == NULL || (HiiValue->Type != EFI_IFR_TYPE_DATE && HiiValue->Type != EFI_IFR_TYPE_TIME)) {
return EFI_INVALID_PARAMETER;
}
if (HiiValue->Type == EFI_IFR_TYPE_DATE) {
EfiTime->Year = HiiValue->Value.date.Year;
EfiTime->Month = HiiValue->Value.date.Month;
EfiTime->Day = HiiValue->Value.date.Day;
} else {
EfiTime->Hour = HiiValue->Value.time.Hour;
EfiTime->Minute = HiiValue->Value.time.Minute;
EfiTime->Second = HiiValue->Value.time.Second;
}
return EFI_SUCCESS;
}
/**
Get next date or time value
@param[in] DateTimeItem Date time item
@param[in] Increasement If true, get next value. Otherwise, get previous value
@param[in, out] EfiTime Pointer to EFI time
@retval EFI_SUCCESS Get next date or time value successfully
@retval EFI_INVALID_PARAMETER EfiTime is NULL or DateTimeItem is invalid
@retval EFI_ABORTED Fail to get next date value
**/
EFI_STATUS
GetNextDateTimeValue (
IN H2O_DATE_TIME_ITEM DateTimeItem,
IN BOOLEAN Increasement,
IN OUT EFI_TIME *EfiTime
)
{
UINT8 DayOfMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
UINT8 MonthIndex;
EFI_TIME EfiTimeValue;
if (EfiTime == NULL) {
return EFI_INVALID_PARAMETER;
}
CopyMem (&EfiTimeValue, EfiTime, sizeof(EFI_TIME));
switch (DateTimeItem) {
case YearItem:
if (Increasement) {
EfiTimeValue.Year = (EfiTimeValue.Year == PcdGet16 (PcdRealTimeClockYearMax)) ? PcdGet16 (PcdRealTimeClockYearMin) : (EfiTimeValue.Year + 1);
} else {
EfiTimeValue.Year = (EfiTimeValue.Year == PcdGet16 (PcdRealTimeClockYearMin)) ? PcdGet16 (PcdRealTimeClockYearMax) : (EfiTimeValue.Year - 1);
}
break;
case MonthItem:
if (Increasement) {
EfiTimeValue.Month = (EfiTimeValue.Month == 12) ? 1 : (EfiTimeValue.Month + 1);
} else {
EfiTimeValue.Month = (EfiTimeValue.Month == 1) ? 12 : (EfiTimeValue.Month - 1);
}
break;
case DayItem:
MonthIndex = EfiTimeValue.Month - 1;
if (Increasement) {
if (EfiTimeValue.Month == 2 && IsLeapYear (EfiTimeValue.Year)) {
EfiTimeValue.Day = (EfiTimeValue.Day == 29) ? 1 : (EfiTimeValue.Day + 1);
} else {
EfiTimeValue.Day = (EfiTimeValue.Day == DayOfMonth[MonthIndex]) ? 1 : (EfiTimeValue.Day + 1);
}
} else {
if (EfiTimeValue.Month == 2 && IsLeapYear (EfiTimeValue.Year)) {
EfiTimeValue.Day = (EfiTimeValue.Day == 1) ? 29 : (EfiTimeValue.Day - 1);
} else {
EfiTimeValue.Day = (EfiTimeValue.Day == 1) ? DayOfMonth[MonthIndex] : (EfiTimeValue.Day - 1);
}
}
break;
case HourItem:
if (Increasement) {
EfiTimeValue.Hour = (EfiTimeValue.Hour == 23) ? 0 : (EfiTimeValue.Hour + 1);
} else {
EfiTimeValue.Hour = (EfiTimeValue.Hour == 0 ) ? 23 : (EfiTimeValue.Hour - 1);
}
break;
case MinuteItem:
if (Increasement) {
EfiTimeValue.Minute = (EfiTimeValue.Minute == 59) ? 0 : (EfiTimeValue.Minute + 1);
} else {
EfiTimeValue.Minute = (EfiTimeValue.Minute == 0) ? 59 : (EfiTimeValue.Minute - 1);
}
break;
case SecondItem:
if (Increasement) {
EfiTimeValue.Second = (EfiTimeValue.Second == 59) ? 0 : (EfiTimeValue.Second + 1);
} else {
EfiTimeValue.Second = (EfiTimeValue.Second == 0) ? 59 : (EfiTimeValue.Second - 1);
}
break;
default:
return EFI_INVALID_PARAMETER;
}
if (DateTimeItem == YearItem || DateTimeItem == MonthItem || DateTimeItem == DayItem) {
while (!IsDayValid (&EfiTimeValue)) {
EfiTimeValue.Day--;
if (EfiTimeValue.Day == 0) {
ASSERT(FALSE);
return EFI_ABORTED;
}
}
}
CopyMem (EfiTime, &EfiTimeValue, sizeof(EFI_TIME));
return EFI_SUCCESS;
}
/**
Get next question value
@param[in] Question Pointer to form browser question
@param[in] GoDown If true, get next value. Otherwise, get previous value
@param[out] ResultHiiValue Pointer to EFI HII value
@retval EFI_SUCCESS Get next question value successfully
@retval EFI_NOT_FOUND Step value is zero if question is numeric opcode or option list is empty if question is oneof opcode
@retval EFI_UNSUPPORTED Question operand is not numeric or oneof opcode
**/
EFI_STATUS
GetNextQuestionValue (
IN H2O_FORM_BROWSER_Q *Question,
IN BOOLEAN GoDown,
OUT EFI_HII_VALUE *ResultHiiValue
)
{
EFI_STATUS Status;
UINT64 Step;
UINT64 Minimum;
UINT64 Maximum;
UINT64 EditValue;
UINT64 CurrentValue;
UINT32 Index;
UINT32 OptionCount;
H2O_FORM_BROWSER_O *OptionList;
H2O_FORM_BROWSER_O *TargetOption;
Status = EFI_NOT_FOUND;
switch (Question->Operand) {
case EFI_IFR_NUMERIC_OP:
if (Question->Step == 0) {
break;
}
Step = Question->Step;
Minimum = Question->Minimum;
Maximum = Question->Maximum == 0 ? ((UINT64) -1) : Question->Maximum;
EditValue = Question->HiiValue.Value.u64;
if ((Question->Flags & EFI_IFR_DISPLAY) == EFI_IFR_DISPLAY_INT_DEC) {
EditValue = (UINT64) IfrNumericConvertValueToInt64 (Question->Flags, EditValue);
Minimum = (UINT64) IfrNumericConvertValueToInt64 (Question->Flags, Minimum);
Maximum = (UINT64) IfrNumericConvertValueToInt64 (Question->Flags, Maximum);
if (GoDown) {
if ((INT64) EditValue + (INT64) Step <= (INT64) Maximum) {
EditValue = (UINT64) ((INT64) EditValue + (INT64) Step);
} else if ((INT64) EditValue < (INT64) Maximum) {
EditValue = Maximum;
} else {
EditValue = Minimum;
}
} else {
if ((INT64) EditValue >= (INT64) Minimum + (INT64) Step) {
EditValue = (UINT64) ((INT64) EditValue - (INT64) Step);
} else if ((INT64) EditValue > (INT64) Minimum){
EditValue = Minimum;
} else {
EditValue = Maximum;
}
}
EditValue = IfrNumericConvertInt64ToValue (Question->Flags, (INT64) EditValue);
} else {
if (GoDown) {
if (EditValue + Step <= Maximum) {
EditValue = EditValue + Step;
} else if (EditValue < Maximum) {
EditValue = Maximum;
} else {
EditValue = Minimum;
}
} else {
if (EditValue >= Minimum + Step) {
EditValue = EditValue - Step;
} else if (EditValue > Minimum){
EditValue = Minimum;
} else {
EditValue = Maximum;
}
}
}
CopyMem (ResultHiiValue, &Question->HiiValue, sizeof (EFI_HII_VALUE));
ResultHiiValue->Value.u64 = EditValue;
Status = EFI_SUCCESS;
break;
case EFI_IFR_ONE_OF_OP:
if (Question->NumberOfOptions == 0 || Question->Options == NULL) {
break;
}
CurrentValue = Question->HiiValue.Value.u64;
OptionList = Question->Options;
OptionCount = (UINT32) Question->NumberOfOptions;
for (Index = 0; Index < OptionCount; Index++) {
if (OptionList[Index].HiiValue.Value.u64 == CurrentValue) {
break;
}
}
if (Index == OptionCount) {
break;
}
TargetOption = &OptionList[Index];
if (GoDown) {
if (Index != OptionCount - 1) {
TargetOption = &OptionList[Index + 1];
} else {
TargetOption = &OptionList[0];
}
} else {
if (Index != 0) {
TargetOption = &OptionList[Index - 1];
} else {
TargetOption = &OptionList[OptionCount - 1];
}
}
if (TargetOption == &OptionList[Index]) {
break;
}
CopyMem (ResultHiiValue, &Question->HiiValue, sizeof (EFI_HII_VALUE));
ResultHiiValue->Value.u64 = TargetOption->HiiValue.Value.u64;
Status = EFI_SUCCESS;
break;
case EFI_IFR_CHECKBOX_OP:
CopyMem (ResultHiiValue, &Question->HiiValue, sizeof (EFI_HII_VALUE));
ResultHiiValue->Value.b = (BOOLEAN) (Question->HiiValue.Value.b ? FALSE : TRUE);
Status = EFI_SUCCESS;
break;
default:
Status = EFI_UNSUPPORTED;
break;
}
return Status;
}
/**
Get opcode value by dialog type
@param[in] DialogType Dialog type
@return opcode value or zero if dialog type is not recognized
**/
UINT8
GetOpCodeByDialogType (
IN UINT32 DialogType
)
{
switch ((DialogType & H2O_FORM_BROWSER_D_TYPE_QUESTIONS) >> 16) {
case H2O_FORM_BROWSER_D_TYPE_ONE_OF:
return EFI_IFR_ONE_OF_OP;
case H2O_FORM_BROWSER_D_TYPE_ORDERED_LIST:
return EFI_IFR_ORDERED_LIST_OP;
case H2O_FORM_BROWSER_D_TYPE_NUMERIC:
return EFI_IFR_NUMERIC_OP;
case H2O_FORM_BROWSER_D_TYPE_STRING:
return EFI_IFR_STRING_OP;
case H2O_FORM_BROWSER_D_TYPE_DATE:
return EFI_IFR_DATE_OP;
case H2O_FORM_BROWSER_D_TYPE_TIME:
return EFI_IFR_TIME_OP;
case H2O_FORM_BROWSER_D_TYPE_PASSWORD:
return EFI_IFR_PASSWORD_OP;
default:
break;
}
return 0;
}
/**
Get HII buffer value by buffer type and index
@param[in] Buffer Pointer to buffer
@param[in] Type Buffer type
@param[in] Index Buffer index
@return buffer value or zero if Buffer is NULL or Type is not recognized
**/
UINT64
GetHiiBufferValue (
IN UINT8 *Buffer,
IN UINT8 Type,
IN UINT32 Index
)
{
UINT64 Data;
ASSERT (Buffer != NULL);
if (Buffer == NULL) {
return 0;
}
Data = 0;
switch (Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
Data = (UINT64) *(((UINT8 *) Buffer) + Index);
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
Data = (UINT64) *(((UINT16 *) Buffer) + Index);
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
Data = (UINT64) *(((UINT32 *) Buffer) + Index);
break;
case EFI_IFR_TYPE_NUM_SIZE_64:
Data = (UINT64) *(((UINT64 *) Buffer) + Index);
break;
default:
break;
}
return Data;
}
/**
Set HII buffer value by buffer type and index
@param[in] Buffer Pointer to buffer
@param[in] Type Buffer type
@param[in] Index Buffer index
@param[in] Value The value to be set
**/
VOID
SetHiiBufferValue (
IN UINT8 *Buffer,
IN UINT8 Type,
IN UINT32 Index,
IN UINT64 Value
)
{
ASSERT (Buffer != NULL);
if (Buffer == NULL) {
return;
}
switch (Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
*(((UINT8 *) Buffer) + Index) = (UINT8) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
*(((UINT16 *) Buffer) + Index) = (UINT16) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
*(((UINT32 *) Buffer) + Index) = (UINT32) Value;
break;
case EFI_IFR_TYPE_NUM_SIZE_64:
*(((UINT64 *) Buffer) + Index) = (UINT64) Value;
break;
default:
break;
}
}
EFI_STATUS
GetSetupMenuInfoByPage (
IN H2O_FORM_BROWSER_P *Page,
OUT SETUP_MENU_INFO *SetupMenuInfo
)
{
EFI_STATUS Status;
H2O_FORM_BROWSER_PROTOCOL *FBProtocol;
H2O_FORM_BROWSER_SM *SetupMenuData;
UINT32 HiiHandleIndex;
UINT32 Index;
SETUP_MENU_INFO *RootSetupMenuInfo;
if (Page == NULL || SetupMenuInfo == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = gBS->LocateProtocol (&gH2OFormBrowserProtocolGuid, NULL, (VOID **) &FBProtocol);
if (EFI_ERROR (Status)) {
return Status;
}
Status = FBProtocol->GetSMInfo (FBProtocol, &SetupMenuData);
if (EFI_ERROR (Status)) {
return Status;
}
RootSetupMenuInfo = NULL;
do {
HiiHandleIndex = Page->PageId >> 16;
for (Index = 0; Index < SetupMenuData->NumberOfSetupMenus; Index++) {
if ((SetupMenuData->SetupMenuInfoList[Index].PageId >> 16) == HiiHandleIndex) {
RootSetupMenuInfo = &SetupMenuData->SetupMenuInfoList[Index];
break;
}
}
Page = Page->ParentPage;
} while (Page != NULL);
if (RootSetupMenuInfo != NULL) {
CopyMem (SetupMenuInfo, RootSetupMenuInfo, sizeof (SETUP_MENU_INFO));
}
FreeSetupMenuData (SetupMenuData);
return (RootSetupMenuInfo != NULL) ? EFI_SUCCESS : EFI_NOT_FOUND;
}
/**
Free form browser setup menu data
@param[in] SetupMenuData Pointer to form browser setup menu data
**/
VOID
FreeSetupMenuData (
IN H2O_FORM_BROWSER_SM *SetupMenuData
)
{
if (SetupMenuData == NULL) {
return;
}
if (SetupMenuData->TitleString != NULL) {
FreePool (SetupMenuData->TitleString);
}
if (SetupMenuData->CoreVersionString != NULL) {
FreePool (SetupMenuData->CoreVersionString);
}
if (SetupMenuData->SetupMenuInfoList != NULL) {
FreePool (SetupMenuData->SetupMenuInfoList);
}
FreePool (SetupMenuData);
}
/**
Get display engine resolution by Pcd
@param[in] DisplayEngineGuid Display engine guid
@param[in] HorizontalResolution Pointer to horizontal resolution
@param[in] VerticalResolution Pointer to vertical resolution
**/
VOID
EFIAPI
GetDisplayEngineResolutionByPcd (
IN EFI_GUID *DisplayEngineGuid,
IN UINT32 *HorizontalResolution,
IN UINT32 *VerticalResolution
)
{
UINT32 Horizontal;
UINT32 Vertical;
OEM_LOGO_RESOLUTION_DEFINITION TempLogoResolution;
OEM_LOGO_RESOLUTION_DEFINITION *LogoResolution;
H2O_DISPLAY_ENGINE_RESOLUTION *DisplayEngineResolution;
UINTN Count;
EFI_STATUS OemSvcStatus;
LogoResolution = (OEM_LOGO_RESOLUTION_DEFINITION *) PcdGetPtr (PcdDefaultLogoResolution);
CopyMem (&TempLogoResolution, LogoResolution, sizeof (OEM_LOGO_RESOLUTION_DEFINITION));
LogoResolution = &TempLogoResolution;
Horizontal = LogoResolution->ScuResolutionX;
Vertical = LogoResolution->ScuResolutionY;
DEBUG_OEM_SVC ((DEBUG_INFO, "OemKernelServices Call: OemSvcLogoResolution \n"));
OemSvcStatus = OemSvcLogoResolution (&LogoResolution);
DEBUG_OEM_SVC ((DEBUG_INFO, "OemKernelServices OemSvcLogoResolution Status: %r\n", OemSvcStatus));
if (Horizontal == 0xFFFF && Vertical == 0xFFFF) {
DisplayEngineResolution = (H2O_DISPLAY_ENGINE_RESOLUTION *)(LogoResolution + 1);
Count = 5;
while (Count--) {
if (CompareGuid (&DisplayEngineResolution->DisplayEngineGuid, DisplayEngineGuid)) {
Horizontal = DisplayEngineResolution->HorizontalResolution;
Vertical = DisplayEngineResolution->VerticalResolution;
break;
}
if (CompareGuid (&DisplayEngineResolution->DisplayEngineGuid, &gZeroGuid)) {
break;
}
DisplayEngineResolution++;
}
} else {
Horizontal = LogoResolution->ScuResolutionX;
Vertical = LogoResolution->ScuResolutionY;
}
*HorizontalResolution = Horizontal;
*VerticalResolution = Vertical;
}
/**
Check if user input key data match key data of hot key.
@param[in] HotKeyKeyData Pointer to input key data
@param[in] UserInputKeyData Pointer to key data of hot key
@retval TRUE User input key data match key data of hot key
@retval FALSE User input key data does not match key data of hot key
**/
STATIC
BOOLEAN
IsHotKeyPressed (
IN EFI_KEY_DATA *HotKeyKeyData,
IN EFI_KEY_DATA *UserInputKeyData
)
{
UINT32 HotKeyState;
UINT32 UserInputState;
BOOLEAN IsMatch;
BOOLEAN CheckCharCase;
ASSERT (HotKeyKeyData != NULL);
ASSERT (UserInputKeyData != NULL);
if (HotKeyKeyData == NULL || UserInputKeyData == NULL) {
return FALSE;
}
CheckCharCase = TRUE;
if (((HotKeyKeyData->KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) == EFI_SHIFT_STATE_VALID) &&
((UserInputKeyData->KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) == EFI_SHIFT_STATE_VALID)) {
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & (EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED));
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & (EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED));
IsMatch = (BOOLEAN) ((HotKeyState == 0 && UserInputState == 0) ||
((HotKeyState == (EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED)) && (UserInputState != 0)) ||
((HotKeyState != (EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED)) && (UserInputState == HotKeyState)));
if (!IsMatch) {
return FALSE;
}
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & (EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED));
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & (EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED));
IsMatch = (BOOLEAN) ((HotKeyState == 0 && UserInputState == 0) ||
((HotKeyState == (EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED)) && (UserInputState != 0)) ||
((HotKeyState != (EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED)) && (UserInputState == HotKeyState)));
if (!IsMatch) {
return FALSE;
}
if (HotKeyState != 0) {
CheckCharCase = FALSE;
}
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & (EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED));
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & (EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED));
IsMatch = (BOOLEAN) ((HotKeyState == 0 && UserInputState == 0) ||
((HotKeyState == (EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED)) && (UserInputState != 0)) ||
((HotKeyState != (EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED)) && (UserInputState == HotKeyState)));
if (!IsMatch) {
return FALSE;
}
if (HotKeyState != 0) {
CheckCharCase = FALSE;
}
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & (EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED));
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & (EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED));
IsMatch = (BOOLEAN) ((HotKeyState == 0 && UserInputState == 0) ||
((HotKeyState == (EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED)) && (UserInputState != 0)) ||
((HotKeyState != (EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED)) && (UserInputState == HotKeyState)));
if (!IsMatch) {
return FALSE;
}
if (HotKeyState != 0) {
CheckCharCase = FALSE;
}
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & EFI_MENU_KEY_PRESSED);
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & EFI_MENU_KEY_PRESSED);
if (HotKeyState != UserInputState) {
return FALSE;
}
if (HotKeyState != 0) {
CheckCharCase = FALSE;
}
HotKeyState = (HotKeyKeyData->KeyState.KeyShiftState & EFI_SYS_REQ_PRESSED);
UserInputState = (UserInputKeyData->KeyState.KeyShiftState & EFI_SYS_REQ_PRESSED);
if (HotKeyState != UserInputState) {
return FALSE;
}
if (HotKeyState != 0) {
CheckCharCase = FALSE;
}
}
if (HotKeyKeyData->Key.ScanCode != UserInputKeyData->Key.ScanCode ||
((CheckCharCase && HotKeyKeyData->Key.UnicodeChar != UserInputKeyData->Key.UnicodeChar) ||
(!CheckCharCase && TO_LOWER_UNICODE_CHAR (HotKeyKeyData->Key.UnicodeChar) != TO_LOWER_UNICODE_CHAR (UserInputKeyData->Key.UnicodeChar)))) {
return FALSE;
}
return TRUE;
}
/**
Get selected hot key info if input key data match one of input hot key info list.
@param[in] KeyData Pointer to input key data
@param[in] HotKeyInfoList Pointer to hot key info list
@param[out] SelectedHotKeyInfo Pointer to selected hot key info
@retval EFI_SUCCESS Get selected hot key info successfully
@retval EFI_NOT_FOUND Input key does not match one of input hot key info list.
@retval EFI_INVALID_PARAMETER KeyData, HotKeyInfoList or SelectedHotKeyInfo is NULL
**/
EFI_STATUS
GetSelectedHotKeyInfoByKeyData (
IN EFI_KEY_DATA *KeyData,
IN HOT_KEY_INFO *HotKeyInfoList,
OUT HOT_KEY_INFO *SelectedHotKeyInfo
)
{
if (KeyData == NULL || HotKeyInfoList == NULL || SelectedHotKeyInfo == NULL) {
return EFI_INVALID_PARAMETER;
}
while (!IS_END_OF_HOT_KEY_INFO (HotKeyInfoList)) {
if (IsHotKeyPressed (&HotKeyInfoList->KeyData, KeyData)) {
CopyMem (SelectedHotKeyInfo, HotKeyInfoList, sizeof (HOT_KEY_INFO));
return EFI_SUCCESS;
}
HotKeyInfoList++;
}
return EFI_NOT_FOUND;
}
Reference in New Issue View Git Blame Copy Permalink