1090 lines
34 KiB
C
1090 lines
34 KiB
C
/** @file
|
|
|
|
;******************************************************************************
|
|
;* Copyright (c) 2012 - 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.
|
|
;*
|
|
;******************************************************************************
|
|
*/
|
|
/**@file
|
|
ME Setup Implementation
|
|
|
|
@copyright
|
|
INTEL CONFIDENTIAL
|
|
Copyright 2008 - 2021 Intel Corporation.
|
|
|
|
The source code contained or described herein and all documents related to the
|
|
source code ("Material") are owned by Intel Corporation or its suppliers or
|
|
licensors. Title to the Material remains with Intel Corporation or its suppliers
|
|
and licensors. The Material may contain trade secrets and proprietary and
|
|
confidential information of Intel Corporation and its suppliers and licensors,
|
|
and is protected by worldwide copyright and trade secret laws and treaty
|
|
provisions. No part of the Material may be used, copied, reproduced, modified,
|
|
published, uploaded, posted, transmitted, distributed, or disclosed in any way
|
|
without Intel's prior express written permission.
|
|
|
|
No license under any patent, copyright, trade secret or other intellectual
|
|
property right is granted to or conferred upon you by disclosure or delivery
|
|
of the Materials, either expressly, by implication, inducement, estoppel or
|
|
otherwise. Any license under such intellectual property rights must be
|
|
express and approved by Intel in writing.
|
|
|
|
Unless otherwise agreed by Intel in writing, you may not remove or alter
|
|
this notice or any other notice embedded in Materials by Intel or
|
|
Intel's suppliers or licensors in any way.
|
|
|
|
This file contains a 'Sample Driver' and is licensed as such under the terms
|
|
of your license agreement with Intel or your vendor. This file may be modified
|
|
by the user, subject to the additional terms of the license agreement.
|
|
|
|
@par Specification Reference:
|
|
**/
|
|
|
|
#include <ChipsetSetupConfig.h>
|
|
#include <IndustryStandard/Pci22.h>
|
|
#include <Library/Tpm2CommandLib.h>
|
|
#include <Library/DxeMeLib.h>
|
|
#include <Library/PttHeciLib.h>
|
|
#include <Library/BootGuardLibVer1.h>
|
|
#include <Library/MeFwStsLib.h>
|
|
#include <Library/HobLib.h>
|
|
#include <Library/DxeAmtHeciLib.h>
|
|
#include <Protocol/AmtWrapperProtocol.h>
|
|
#include <Protocol/OneClickRecoveryProtocol.h>
|
|
#include <Register/MeRegs.h>
|
|
#include <Register/HeciRegs.h>
|
|
//[-start-200215-IB06462109-remove]//
|
|
//#include <SetupPrivate.h>
|
|
//[-end-200215-IB06462109-remove]//
|
|
#include <MeSetup.h>
|
|
//[-start-200215-IB06462109-remove]//
|
|
//#include <OemSetup.h>
|
|
//[-end-200215-IB06462109-remove]//
|
|
//[-start-200215-IB06462109-remove]//
|
|
//#include <TcgSetup.h>
|
|
//[-end-200215-IB06462109-remove]//
|
|
#include <CpuRegs.h>
|
|
#include <MeFwHob.h>
|
|
|
|
//[-start-200215-IB06462109-add]//
|
|
#include <Library/PciLib.h>
|
|
#include <Library/DxeAmtHeciLib.h>
|
|
#include <SetupUtility.h>
|
|
#include <PlatformDefinitions.h>
|
|
#include <Library/PciSegmentLib.h>
|
|
#include <Library/DxeAsfLib.h>
|
|
//[-end-200215-IB06462109-add]//
|
|
|
|
///
|
|
/// HECI PCI Access Macro
|
|
///
|
|
#define HeciPciSegmentRead32(Register) PciSegmentRead32 (PCI_SEGMENT_LIB_ADDRESS (ME_SEGMENT, ME_BUS, ME_DEVICE_NUMBER, HECI_FUNCTION_NUMBER, Register))
|
|
|
|
//[-start-200215-IB06462109-add]//
|
|
ME_SETUP mMeSetup;
|
|
//[-end-200215-IB06462109-add]//
|
|
|
|
|
|
GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN mMeReset = FALSE;
|
|
GLOBAL_REMOVE_IF_UNREFERENCED EFI_HII_HANDLE mHiiHandle;
|
|
GLOBAL_REMOVE_IF_UNREFERENCED EFI_EVENT mRemoteSessionEvent;
|
|
|
|
/**
|
|
Initialize KVM by sending HECI message to ME
|
|
|
|
@param[in] Event The event registered.
|
|
@param[in] Context Event context. Not used in this event handler.
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
RemoteSessionDetection (
|
|
IN EFI_EVENT Event,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
AMT_WRAPPER_PROTOCOL *AmtWrapper;
|
|
ME_SETUP_STORAGE MeSetupStorage;
|
|
EFI_STRING RequestString;
|
|
EFI_TPL OldTpl;
|
|
|
|
DEBUG ((DEBUG_INFO, "%a () enter\n", __FUNCTION__));
|
|
RequestString = NULL;
|
|
OldTpl = EfiGetCurrentTpl ();
|
|
|
|
gBS->RestoreTPL (TPL_APPLICATION);
|
|
|
|
Status = gBS->LocateProtocol (&gAmtWrapperProtocolGuid, NULL, (VOID **) &AmtWrapper);
|
|
if (!EFI_ERROR (Status)) {
|
|
RequestString = HiiConstructRequestString (RequestString, OFFSET_OF (ME_SETUP_STORAGE, RemoteSessionActive), sizeof (MeSetupStorage.RemoteSessionActive));
|
|
HiiGetBrowserData (&gMeSetupVariableGuid, L"MeSetupStorage", sizeof (ME_SETUP_STORAGE), (UINT8 *) &MeSetupStorage);
|
|
if ((MeSetupStorage.RemoteSessionActive == 0) && AmtWrapper->IsKvmEnabled ()) {
|
|
CreatePopUp (
|
|
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,
|
|
NULL,
|
|
L"",
|
|
L"Remote Session is open in PCH-FW Configuration.",
|
|
L"System needs to reset to set up item attribute.",
|
|
L"Reset system in 5 seconds...",
|
|
L"",
|
|
NULL
|
|
);
|
|
gBS->Stall (5000000);;
|
|
gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
|
|
}
|
|
FreePool (RequestString);
|
|
}
|
|
gBS->RaiseTPL (OldTpl);
|
|
DEBUG ((DEBUG_INFO, "%a () exit\n", __FUNCTION__));
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
Check remote session status.
|
|
|
|
If remote session is open, keep it as it is.
|
|
If remote session is not open, because it might be open in runtime,
|
|
BIOS needs to take care of the scenario accordingly.
|
|
|
|
@param[in] Action Specifies the type of action taken by the browser.
|
|
@param[in] KeyValue A unique value which is sent to the original exporting driver
|
|
so that it can identify the type of data to expect.
|
|
**/
|
|
VOID
|
|
CheckRemoteSession (
|
|
IN EFI_BROWSER_ACTION Action,
|
|
IN EFI_QUESTION_ID KeyValue
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
AMT_WRAPPER_PROTOCOL *AmtWrapper;
|
|
EFI_STRING RequestString;
|
|
ME_SETUP_STORAGE MeSetupStorage;
|
|
VOID *AfterConsolInNotifyReg;
|
|
static BOOLEAN IsConsoleEventCreated = FALSE;
|
|
|
|
DEBUG ((DEBUG_INFO, "%a () enter, Action = 0x%x\n", __FUNCTION__, Action));
|
|
|
|
RequestString = NULL;
|
|
Status = EFI_SUCCESS;
|
|
|
|
RequestString = HiiConstructRequestString (RequestString, OFFSET_OF (ME_SETUP_STORAGE, RemoteSessionActive), sizeof (MeSetupStorage.RemoteSessionActive));
|
|
if (RequestString == NULL) {
|
|
return;
|
|
}
|
|
HiiGetBrowserData (&gMeSetupVariableGuid, L"MeSetupStorage", sizeof (ME_SETUP_STORAGE), (UINT8 *)&MeSetupStorage);
|
|
|
|
//
|
|
// If remote session is opened or closed after entering setup page, BIOS can update RemoteSessionActive value here.
|
|
//
|
|
if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
|
|
Status = gBS->LocateProtocol (&gAmtWrapperProtocolGuid, NULL, (VOID **) &AmtWrapper);
|
|
if (!EFI_ERROR (Status)) {
|
|
MeSetupStorage.RemoteSessionActive = AmtWrapper->IsStorageRedirectionEnabled () ||
|
|
AmtWrapper->IsSolEnabled () ||
|
|
AmtWrapper->IsKvmEnabled ();
|
|
HiiSetBrowserData (&gMeSetupVariableGuid, L"MeSetupStorage", sizeof(ME_SETUP_STORAGE), (UINT8 *)&MeSetupStorage, RequestString);
|
|
FreePool (RequestString);
|
|
}
|
|
}
|
|
|
|
if (MeSetupStorage.RemoteSessionActive == 1) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Remote session could be opened/closed after entering PCH-FW configuration page, BIOS should create event to update RemoteSessionActive in below conditions:
|
|
// 1. Create event to detect remote session open when entering PCH-FW or AMT Configuration
|
|
// 2. Close event only when exiting PCH-FW configuration.
|
|
//
|
|
if (Action == EFI_BROWSER_ACTION_FORM_OPEN &&
|
|
(KeyValue == ME_FORM_ACTION_KEY || KeyValue == AMT_FORM_ACTION_KEY)) {
|
|
//
|
|
// If remote session is opened after entering "PCH-FW Configuration", the "grayoutif" capability can't be changed in real time.
|
|
// Below event is used to detect this scenario and trigger warm reset.
|
|
//
|
|
if ((MeSetupStorage.RemoteSessionActive == 0) && !IsConsoleEventCreated) {
|
|
IsConsoleEventCreated = TRUE;
|
|
DEBUG ((DEBUG_INFO, "Create RemoteSessionDetection event\n"));
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_SIGNAL,
|
|
TPL_NOTIFY,
|
|
RemoteSessionDetection,
|
|
NULL,
|
|
&mRemoteSessionEvent
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->RegisterProtocolNotify (
|
|
&gEfiConsoleInDeviceGuid,
|
|
mRemoteSessionEvent,
|
|
&AfterConsolInNotifyReg
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
}
|
|
} else if (Action == EFI_BROWSER_ACTION_FORM_CLOSE && KeyValue == ME_FORM_ACTION_KEY && IsConsoleEventCreated) {
|
|
DEBUG ((DEBUG_INFO, "Close RemoteSessionDetection event\n"));
|
|
IsConsoleEventCreated = FALSE;
|
|
Status = gBS->CloseEvent (mRemoteSessionEvent);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//[-start-200826-IB16740113-add]// The function exist in HiiConfigAccess.c, RC1341 use it.
|
|
/**
|
|
Converts the low nibble of a byte to hex unicode character.
|
|
|
|
@param[in] Nibble - lower nibble of a byte.
|
|
|
|
Hex unicode character.
|
|
|
|
**/
|
|
CHAR16
|
|
NibbleToHexChar (
|
|
IN UINT8 Nibble
|
|
)
|
|
{
|
|
Nibble &= 0x0F;
|
|
if (Nibble <= 0x9) {
|
|
return (CHAR16)(Nibble + L'0');
|
|
}
|
|
|
|
return (CHAR16)(Nibble - 0xA + L'A');
|
|
}
|
|
//[-end-200826-IB16740113-add]//
|
|
|
|
/**
|
|
Converts the low nibble of a byte to hex unicode character.
|
|
|
|
@param[in] Nibble Lower nibble of a byte
|
|
|
|
@retval CHAR16 Hex unicode character
|
|
**/
|
|
CHAR16
|
|
NibbleToHexChar (
|
|
IN UINT8 Nibble
|
|
);
|
|
|
|
/**
|
|
Converts retrieved byte to string adding a hyphen after every 2nd byte.
|
|
|
|
@param[out] String Unicode String
|
|
@param[in] Buffer Hash in hex format
|
|
@param[in] Length Max length of hash to convert
|
|
**/
|
|
VOID
|
|
BinaryToHexString (
|
|
OUT UINT16 *String,
|
|
IN UINT8 *Buffer,
|
|
IN UINTN Length
|
|
)
|
|
{
|
|
UINTN Index;
|
|
UINT8 Byte;
|
|
|
|
for (Index = 0; Index < Length; Index++) {
|
|
|
|
if ((Index % 2 == 0) && (Index != 0)) {
|
|
*String = '-';
|
|
String++;
|
|
}
|
|
Byte = Buffer[Index];
|
|
*String = NibbleToHexChar ((UINT8)(Byte >> 4));
|
|
*(String + 1) = NibbleToHexChar (Byte);
|
|
String += 2;
|
|
}
|
|
|
|
*String = '\0';
|
|
}
|
|
|
|
/**
|
|
Sets One Click Recovery Setup Options are Supported
|
|
**/
|
|
VOID
|
|
SetOcrSetupSupported (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN VariableSize;
|
|
UINT32 SetupVolVarAttr;
|
|
SETUP_VOLATILE_DATA VolatileData;
|
|
ONE_CLICK_RECOVERY_PROTOCOL *OneClickRecovery;
|
|
ONE_CLICK_RECOVERY_CAP OcrCap;
|
|
|
|
Status = gBS->LocateProtocol (&gOneClickRecoveryProtocolGuid, NULL, (VOID **)&OneClickRecovery);
|
|
if (!EFI_ERROR (Status)) {
|
|
OcrCap = OneClickRecovery->OcrCap ();
|
|
|
|
VariableSize = sizeof (SETUP_VOLATILE_DATA);
|
|
Status = gRT->GetVariable (
|
|
L"SetupVolatileData",
|
|
&gSetupVariableGuid,
|
|
&SetupVolVarAttr,
|
|
&VariableSize,
|
|
&VolatileData
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
VolatileData.OcrBootHttpsSupported = OcrCap.Bits.OcrBootHttps;
|
|
VolatileData.OcrBootPbaSupported = OcrCap.Bits.OcrBootPba;
|
|
VolatileData.OcrBootWinReSupported = OcrCap.Bits.OcrBootWinRe;
|
|
VolatileData.OcrAmtDisSecBootSupported = OcrCap.Bits.OcrAmtDisSecBoot;
|
|
|
|
Status = gRT->SetVariable (
|
|
L"SetupVolatileData",
|
|
&gSetupVariableGuid,
|
|
SetupVolVarAttr,
|
|
sizeof (SETUP_VOLATILE_DATA),
|
|
&VolatileData
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
}
|
|
}
|
|
|
|
/**
|
|
Initialize ME strings.
|
|
|
|
@param[in] HiiHandle Hii Handle.
|
|
@param[in] Class Setup form class.
|
|
**/
|
|
VOID
|
|
InitMeInfo (
|
|
IN EFI_HII_HANDLE HiiHandle,
|
|
IN UINT16 Class
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN VariableSize;
|
|
UINT8 *MeFwSkuValue;
|
|
CHAR16 String[0x100];
|
|
UINTN StringLength;
|
|
//[-start-200309-IB14630347-add]//
|
|
UINT8 MeFwInfo;
|
|
//[-end-200309-IB14630347-add]//
|
|
static EFI_STRING_ID MeMode[] = {
|
|
STRING_TOKEN(STR_ME_FW_MODE_NORMAL_MODE),
|
|
STRING_TOKEN(STR_ME_FW_MODE_FAILED),
|
|
STRING_TOKEN(STR_ME_FW_MODE_ALT_DISABLED),
|
|
STRING_TOKEN(STR_ME_FW_MODE_TEMP_DISABLED),
|
|
STRING_TOKEN(STR_ME_FW_MODE_SECOVER),
|
|
STRING_TOKEN(STR_ME_FW_MODE_FAILED),
|
|
STRING_TOKEN(STR_ME_FW_MODE_FAILED),
|
|
};
|
|
static UINT8 *FwMeSku[] = {
|
|
(UINT8*) ME_FW_IMAGE_TYPE_CONSUMER_STRING,
|
|
(UINT8*) ME_FW_IMAGE_TYPE_CORPORATE_STRING,
|
|
(UINT8*) ME_FW_IMAGE_TYPE_UNIDENTIFIED_STRING,
|
|
};
|
|
ME_INFO_SETUP_DATA MeInfoSetupData;
|
|
ME_FW_HOB *MeFwHob;
|
|
UINT32 Index;
|
|
UINT32 MeFwStatus;
|
|
UINT32 MeFwStatus2;
|
|
UINT32 MeFwStatus3;
|
|
UINT32 MeFwStatus4;
|
|
UINT32 MeFwStatus5;
|
|
UINT32 MeFwStatus6;
|
|
|
|
if ((Class != MAIN_FORM_SET_CLASS) && (Class != ADVANCED_FORM_SET_CLASS)) {
|
|
return;
|
|
}
|
|
|
|
mHiiHandle = HiiHandle;
|
|
MeFwHob = NULL;
|
|
Index = 0;
|
|
MeFwStatus = 0;
|
|
MeFwStatus2 = 0;
|
|
MeFwStatus3 = 0;
|
|
MeFwStatus4 = 0;
|
|
MeFwStatus5 = 0;
|
|
MeFwStatus6 = 0;
|
|
|
|
DEBUG ((DEBUG_INFO, "%a() enter\n", __FUNCTION__));
|
|
|
|
//
|
|
// Set default string size assumption at no more than 256 bytes
|
|
//
|
|
StringLength = 0x100;
|
|
|
|
VariableSize = sizeof (ME_INFO_SETUP_DATA);
|
|
Status = gRT->GetVariable (
|
|
L"MeInfoSetup",
|
|
&gMeInfoSetupGuid,
|
|
NULL,
|
|
&VariableSize,
|
|
&MeInfoSetupData
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return;
|
|
}
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_VERSION_VALUE),
|
|
L"%d.%d.%d.%d",
|
|
MeInfoSetupData.MeMajor,
|
|
MeInfoSetupData.MeMinor,
|
|
MeInfoSetupData.MeHotFix,
|
|
MeInfoSetupData.MeBuildNo
|
|
);
|
|
|
|
//[-start-200309-IB14630348-modify]//
|
|
MeFwInfo = MeInfoSetupData.MeFirmwareInfo & ME_MODE_MASK;
|
|
if (MeFwInfo < sizeof (MeMode) / sizeof (EFI_STRING_ID)) {
|
|
StringLength = sizeof (String);
|
|
Status = HiiLibGetString (mHiiHandle, MeMode[MeFwInfo], String, &StringLength);
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_ME_FW_MODE_VALUE), L"%s", String);
|
|
}
|
|
//[-end-200309-IB14630348-modify]//
|
|
|
|
VariableSize = sizeof (ME_SETUP);
|
|
Status = gRT->GetVariable (
|
|
L"MeSetup",
|
|
&gMeSetupVariableGuid,
|
|
NULL,
|
|
&VariableSize,
|
|
&mMeSetup
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
if (mMeSetup.MeImageType == ME_IMAGE_CONSUMER_SKU_FW) {
|
|
MeFwSkuValue = FwMeSku[0];
|
|
} else if (mMeSetup.MeImageType == ME_IMAGE_CORPORATE_SKU_FW) {
|
|
MeFwSkuValue = FwMeSku[1];
|
|
} else {
|
|
MeFwSkuValue = FwMeSku[2];
|
|
}
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_SKU_VALUE),
|
|
L"%a",
|
|
MeFwSkuValue
|
|
);
|
|
|
|
#if FixedPcdGet8 (PcdOneClickRecoveryEnable) == 0x1
|
|
SetOcrSetupSupported ();
|
|
#endif
|
|
|
|
//
|
|
// Check if Heci device is enabled
|
|
//
|
|
if (HeciPciSegmentRead32 (PCI_VENDOR_ID_OFFSET) == 0xFFFFFFFF) {
|
|
//[-start-190709-16990077-add]//
|
|
EFI_ME_STATUS_PROTOCOL *MeStatus;
|
|
|
|
Status = gBS->LocateProtocol (
|
|
&gH2OMeStatusProtocolGuid,
|
|
NULL,
|
|
(VOID **) &MeStatus
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
DEBUG ((DEBUG_ERROR, "gH2OMeStatusProtocolGuid locate unsuccessfully.\n"));
|
|
return;
|
|
|
|
}
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_1_VALUE),
|
|
L"0x%08x",
|
|
MeStatus->Status1
|
|
);
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_2_VALUE),
|
|
L"0x%08x",
|
|
MeStatus->Status2
|
|
);
|
|
//[-end-190709-16990077-add]//
|
|
|
|
DEBUG ((DEBUG_INFO, "ME is disabled, read status from MeFwHob\n"));
|
|
MeFwHob = GetFirstGuidHob (&gMeFwHobGuid);
|
|
if (MeFwHob != NULL) {
|
|
Index = FindMeFwStsIndex (R_ME_HFS);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
|
|
Index = FindMeFwStsIndex (R_ME_HFS_2);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus2 = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
|
|
Index = FindMeFwStsIndex (R_ME_HFS_3);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus2 = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
|
|
Index = FindMeFwStsIndex (R_ME_HFS_4);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus2 = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
|
|
Index = FindMeFwStsIndex (R_ME_HFS_5);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus2 = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
|
|
Index = FindMeFwStsIndex (R_ME_HFS_6);
|
|
if (Index != 0xFF) {
|
|
MeFwStatus2 = MeFwHob->Group[HECI1_DEVICE].Reg[Index];
|
|
}
|
|
}
|
|
} else {
|
|
MeFwStatus = HeciPciSegmentRead32 (R_ME_HFS);
|
|
MeFwStatus2 = HeciPciSegmentRead32 (R_ME_HFS_2);
|
|
MeFwStatus3 = HeciPciSegmentRead32 (R_ME_HFS_3);
|
|
MeFwStatus4 = HeciPciSegmentRead32 (R_ME_HFS_4);
|
|
MeFwStatus5 = HeciPciSegmentRead32 (R_ME_HFS_5);
|
|
MeFwStatus6 = HeciPciSegmentRead32 (R_ME_HFS_6);
|
|
}
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_1_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus
|
|
);
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_2_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus2
|
|
);
|
|
|
|
//[-start-200215-IB06462109-add]//
|
|
MeExtractConfig ();
|
|
//[-end-200215-IB06462109-add]//
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_3_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus3
|
|
);
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_4_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus4
|
|
);
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_5_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus5
|
|
);
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_STATUS_6_VALUE),
|
|
L"0x%08x",
|
|
MeFwStatus6
|
|
);
|
|
}
|
|
|
|
VOID
|
|
MeRouteConfig (
|
|
VOID
|
|
)
|
|
{
|
|
ME_SETUP_STORAGE MeSetupStorage = {0};
|
|
ME_SETUP_STORAGE MeBackupStorage = {0};
|
|
//[-start-200215-IB06462109-modify]//
|
|
// TCG_SETUP TcgSetup = {0};
|
|
KERNEL_CONFIGURATION KernelConfig;
|
|
//[-end-200215-IB06462109-modify]//
|
|
UINTN Size;
|
|
EFI_STATUS Status;
|
|
UINT32 EnableBitmap;
|
|
UINT32 DisableBitmap;
|
|
HECI_PROTOCOL *Heci;
|
|
|
|
DEBUG ((DEBUG_INFO, "%a () enter\n", __FUNCTION__));
|
|
|
|
//[-start-201127-IB17510129-add]//
|
|
CHIPSET_CONFIGURATION ChipsetConfig;
|
|
|
|
Size = sizeof (CHIPSET_CONFIGURATION);
|
|
Status = gRT->GetVariable (
|
|
L"Setup",
|
|
&gSystemConfigurationGuid,
|
|
NULL,
|
|
&Size,
|
|
(VOID *)&ChipsetConfig
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "ChipsetConfig does not exist\n"));
|
|
ASSERT_EFI_ERROR (Status);
|
|
}
|
|
//[-end-201127-IB17510129-add]//
|
|
|
|
Status = gBS->LocateProtocol (&gHeciProtocolGuid, NULL, (VOID **) &Heci);
|
|
if (MeIsAfterEndOfPost () || EFI_ERROR (Status)) {
|
|
return;
|
|
}
|
|
|
|
Size = sizeof (ME_SETUP_STORAGE);
|
|
gRT->GetVariable (L"MeSetupStorage", &gMeSetupVariableGuid, NULL, &Size, &MeSetupStorage);
|
|
gRT->GetVariable (L"MeBackupStorage", &gMeSetupVariableGuid, NULL, &Size, &MeBackupStorage);
|
|
Size = sizeof (ME_SETUP);
|
|
gRT->GetVariable (L"MeSetup", &gMeSetupVariableGuid, NULL, &Size, &mMeSetup);
|
|
//[-start-200215-IB06462109-modify]//
|
|
// Size = sizeof (TCG_SETUP);
|
|
// gRT->GetVariable (L"TcgSetup", &gSetupVariableGuid, NULL, &Size, &TcgSetup);
|
|
Status = GetKernelConfiguration (&KernelConfig);
|
|
//[-end-200215-IB06462109-modify]//
|
|
if (MeSetupStorage.InvokeArbSvnCommit != MeBackupStorage.InvokeArbSvnCommit) {
|
|
if ((mMeSetup.AutoArbSvnCommit == 0) && (MeSetupStorage.InvokeArbSvnCommit == 1)) {
|
|
Status = HeciArbSvnCommitMsg ();
|
|
}
|
|
}
|
|
|
|
if (MeSetupStorage.MeStateControl != MeBackupStorage.MeStateControl) {
|
|
mMeReset = TRUE;
|
|
|
|
if (MeSetupStorage.MeStateControl == 0) {
|
|
Status = HeciSetMeDisableMsg ();
|
|
} else {
|
|
Status = HeciSetMeEnableMsg ();
|
|
}
|
|
}
|
|
|
|
if (MeSetupStorage.FwUpdEnabled != MeBackupStorage.FwUpdEnabled) {
|
|
Status = HeciSetFwUpdateState (MeSetupStorage.FwUpdEnabled);
|
|
}
|
|
|
|
if (MeSetupStorage.MngState != MeBackupStorage.MngState) {
|
|
mMeReset = TRUE;
|
|
if (MeSetupStorage.MngState == 1) {
|
|
//
|
|
// User wants to enable Manageability Features
|
|
//
|
|
EnableBitmap = AMT_BITMASK;
|
|
DisableBitmap = CLEAR_FEATURES_BITMASK;
|
|
} else {
|
|
//
|
|
// User wants to disable Manageability Features
|
|
//
|
|
EnableBitmap = CLEAR_FEATURES_BITMASK;
|
|
DisableBitmap = AMT_BITMASK;
|
|
}
|
|
Status = HeciFwFeatureStateOverride (EnableBitmap, DisableBitmap);
|
|
}
|
|
|
|
if (MeSetupStorage.PttState != MeBackupStorage.PttState) {
|
|
mMeReset = TRUE;
|
|
}
|
|
|
|
//
|
|
// Pass BIOS TPM Deactivate setting to BtG ACM
|
|
//
|
|
if (MeSetupStorage.TpmDeactivate != MeBackupStorage.TpmDeactivate) {
|
|
//[-start-200215-IB06462109-modify]//
|
|
// if (TcgSetup.dTpm12Present == 1) {
|
|
if (KernelConfig.TpmDeviceOk == 1) {
|
|
//[-end-200215-IB06462109-modify]//
|
|
DEBUG ((DEBUG_INFO, "TPM is present.\nCalling HeciSetAcmTpmData\n"));
|
|
Status = HeciSetAcmTpmData (MeSetupStorage.TpmDeactivate);
|
|
} else {
|
|
DEBUG ((DEBUG_INFO, "TPM is not present, do not send MKHI ACM TPM Data.\n"));
|
|
}
|
|
}
|
|
|
|
if (MeSetupStorage.DelayedAuthenticationMode != MeBackupStorage.DelayedAuthenticationMode) {
|
|
mMeReset = TRUE;
|
|
HeciSetDamState (MeSetupStorage.DelayedAuthenticationMode);
|
|
}
|
|
|
|
//[-start-201127-IB17510129-add]//
|
|
if (MeSetupStorage.FipsModeSelect == 0) {
|
|
ChipsetConfig.FipsAutoSync = 0;
|
|
}
|
|
//[-end-201127-IB17510129-add]//
|
|
|
|
if (MeSetupStorage.FipsModeSelect != MeBackupStorage.FipsModeSelect) {
|
|
HeciSetFipsMode (MeSetupStorage.FipsModeSelect);
|
|
}
|
|
|
|
if (MeSetupStorage.UpidState != MeBackupStorage.UpidState) {
|
|
HeciSetUpidFeatureState (UpidFeaturePlatId, MeSetupStorage.UpidState);
|
|
}
|
|
|
|
if (MeSetupStorage.UpidOsControlState != MeBackupStorage.UpidOsControlState) {
|
|
HeciSetUpidOsControlState (UpidFeaturePlatId, MeSetupStorage.UpidOsControlState);
|
|
}
|
|
|
|
|
|
//
|
|
// Remember current FW's state to avoid sending unnecessary messages next time
|
|
//
|
|
gRT->SetVariable (
|
|
L"MeBackupStorage",
|
|
&gMeSetupVariableGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof (ME_SETUP_STORAGE),
|
|
&MeSetupStorage
|
|
);
|
|
//[-start-201127-IB17510129-add]//
|
|
gRT->SetVariable (
|
|
L"Setup",
|
|
&gSystemConfigurationGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof (CHIPSET_CONFIGURATION),
|
|
&ChipsetConfig
|
|
);
|
|
//[-end-201127-IB17510129-add]//
|
|
}
|
|
|
|
/**
|
|
Setup callback executed when user selects PCH-FW configuration from the BIOS UI.
|
|
Changes strings and settings of certain options.
|
|
|
|
@param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
|
|
@param[in] Action Specifies the type of action taken by the browser.
|
|
@param[in] KeyValue A unique value which is sent to the original exporting driver
|
|
so that it can identify the type of data to expect.
|
|
@param[in] Type The type of value for the question.
|
|
@param[in] Value A pointer to the data being sent to the original exporting driver.
|
|
@param[out] ActionRequest On return, points to the action requested by the callback function.
|
|
|
|
@retval EFI_SUCCESS The callback successfully handled the action
|
|
@retval EFI_UNSUPPORTED The specified action is not supported by the callback
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
MeFormCallBackFunction (
|
|
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
|
|
IN EFI_BROWSER_ACTION Action,
|
|
IN EFI_QUESTION_ID KeyValue,
|
|
IN UINT8 Type,
|
|
IN EFI_IFR_TYPE_VALUE *Value,
|
|
OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
BOOLEAN PttCapability;
|
|
BOOLEAN PttCurrentState;
|
|
ME_SETUP_STORAGE MeSetupStorage;
|
|
UINTN Size;
|
|
UINT32 VariableAttr;
|
|
|
|
DEBUG ((DEBUG_INFO, "%a () enter, Action = 0x%x, KeyValue = 0x%x\n", __FUNCTION__, Action, KeyValue));
|
|
|
|
if (Action >= EFI_BROWSER_ACTION_DEFAULT_STANDARD) {
|
|
switch (KeyValue) {
|
|
case MNG_STATE_KEY:
|
|
case DAM_STATE_KEY:
|
|
return EFI_SUCCESS;
|
|
|
|
default:
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If it is corporate image and both RemoteSessionActive/AfterEoP are 0, BIOS needs to check remote session status in runtime.
|
|
//
|
|
Size = sizeof (ME_SETUP_STORAGE);
|
|
Status = gRT->GetVariable (L"MeSetupStorage", &gMeSetupVariableGuid, &VariableAttr, &Size, &MeSetupStorage);
|
|
if (!EFI_ERROR (Status) &&
|
|
(mMeSetup.MeImageType == ME_IMAGE_CORPORATE_SKU_FW) &&
|
|
(MeSetupStorage.RemoteSessionActive == 0) &&
|
|
(MeSetupStorage.AfterEoP == 0)) {
|
|
CheckRemoteSession (Action, KeyValue);
|
|
}
|
|
|
|
if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
|
|
switch (KeyValue) {
|
|
|
|
case PTT_TRIGGER_FORM_OPEN_ACTION_KEY:
|
|
Status = PttHeciGetCapability (&PttCapability);
|
|
if (EFI_ERROR (Status)) {
|
|
PttCapability = FALSE;
|
|
}
|
|
Status = PttHeciGetState (&PttCurrentState);
|
|
if (EFI_ERROR (Status)) {
|
|
PttCurrentState = FALSE;
|
|
}
|
|
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_PTT_CAP_STATE_VALUE),
|
|
L"%d / %d",
|
|
PttCapability,
|
|
PttCurrentState
|
|
);
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
default:
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
VOID
|
|
MeExtractConfig (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 FwUpdateState;
|
|
UINT32 MeMode;
|
|
MEFWCAPS_SKU CurrentFeatures;
|
|
ME_SETUP_STORAGE MeSetupStorage;
|
|
UINTN Size;
|
|
UINT32 VariableAttr;
|
|
AMT_WRAPPER_PROTOCOL *AmtWrapper;
|
|
HECI_FW_STS4_REGISTER MeFwSts4;
|
|
UINT32 MsrValue;
|
|
HECI_PROTOCOL *Heci;
|
|
CHAR16 String[80]; // Fit 64 chars of UPID String + 15 dashes + Null char
|
|
UINTN StringLength;
|
|
EFI_STRING_ID FipsMode[] = {
|
|
STRING_TOKEN(STR_DISABLED),
|
|
STRING_TOKEN(STR_ENABLED)
|
|
};
|
|
GET_FIPS_MODE_DATA FipsModeData;
|
|
UINT32 NumOfEntries;
|
|
ARB_SVN_INFO_ENTRY *ArbSvnInfo;
|
|
MEFWCAPS_SKU UserCapabilities;
|
|
UINT32 Index;
|
|
UINT32 OemPlatformIdType;
|
|
UINT8 OemPlatformId[MAX_PLAT_ID_SIZE];
|
|
UINT8 CsmePlatformId[MAX_PLAT_ID_SIZE];
|
|
|
|
DEBUG ((DEBUG_INFO, "%a () enter\n", __FUNCTION__));
|
|
|
|
AmtWrapper = NULL;
|
|
VariableAttr = 0;
|
|
NumOfEntries = MFT_KEY_USAGE_INDEX_UNDEFINED_MANIFEST;
|
|
ArbSvnInfo = NULL;
|
|
Index = 0;
|
|
|
|
ArbSvnInfo = AllocateZeroPool (NumOfEntries * sizeof (ARB_SVN_INFO_ENTRY));
|
|
if (ArbSvnInfo != NULL) {
|
|
Status = HeciArbSvnGetInfoMsg (&NumOfEntries, ArbSvnInfo);
|
|
|
|
if (!EFI_ERROR (Status)) {
|
|
for (Index = 0; Index < NumOfEntries; Index++) {
|
|
//
|
|
// BIOS should always display the entry with MFT_KEY_USAGE_INDEX_CSE_RBE_MANIFEST
|
|
//
|
|
if (ArbSvnInfo[Index].UsageId == MFT_KEY_USAGE_INDEX_CSE_RBE_MANIFEST) {
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_ARB_SVN_MIN_VALUE), L"%d", ArbSvnInfo[Index].MinAllowedSvn);
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_ARB_SVN_CURR_VALUE), L"%d", ArbSvnInfo[Index].ExecutingSvn);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Size = sizeof (ME_SETUP_STORAGE);
|
|
Status = gRT->GetVariable (L"MeSetupStorage", &gMeSetupVariableGuid, &VariableAttr, &Size, &MeSetupStorage);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "MeSetupStorage does not exist. Assuming default values.\n"));
|
|
VariableAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS;
|
|
MeSetupStorage.MngState = 1;
|
|
MeSetupStorage.FwUpdEnabled = 1;
|
|
MeSetupStorage.MeStateControl = 0;
|
|
MeSetupStorage.AfterEoP = 0;
|
|
MeSetupStorage.RemoteSessionActive = 0;
|
|
MeSetupStorage.PttState = 0;
|
|
MeSetupStorage.BootGuardSupport = 0;
|
|
MeSetupStorage.MeasureBoot = 0;
|
|
MeSetupStorage.TpmDeactivate = 0;
|
|
MeSetupStorage.DelayedAuthenticationMode = 0;
|
|
MeSetupStorage.FipsModeSelect = 0;
|
|
MeSetupStorage.AmtState = 1;
|
|
MeSetupStorage.UpidSupport = 0;
|
|
MeSetupStorage.UpidState = 0;
|
|
MeSetupStorage.UpidOsControlState = 0;
|
|
MeSetupStorage.ActiveLanInterface = 0;
|
|
}
|
|
|
|
//
|
|
// Always disable InvokeArbSvnCommit setup option
|
|
//
|
|
MeSetupStorage.InvokeArbSvnCommit = 0;
|
|
|
|
HeciGetDamState (&MeSetupStorage.DelayedAuthenticationMode);
|
|
|
|
if (IsBootGuardSupported ()) {
|
|
MeSetupStorage.BootGuardSupport = 1;
|
|
}
|
|
|
|
MsrValue = (UINT32) AsmReadMsr64 (MSR_BOOT_GUARD_SACM_INFO);
|
|
if (MsrValue & B_BOOT_GUARD_SACM_INFO_MEASURED_BOOT) {
|
|
MeSetupStorage.MeasureBoot = 1;
|
|
}
|
|
|
|
if (MeIsAfterEndOfPost ()) {
|
|
MeSetupStorage.AfterEoP = 1;
|
|
} else {
|
|
MeSetupStorage.AfterEoP = 0;
|
|
}
|
|
|
|
Status = gBS->LocateProtocol (&gHeciProtocolGuid, NULL, (VOID **) &Heci);
|
|
if (EFI_ERROR (Status)) {
|
|
MeSetupStorage.AfterEoP = 1;
|
|
goto Done;
|
|
}
|
|
|
|
Heci->GetMeMode (&MeMode);
|
|
if (MeMode == ME_MODE_NORMAL) {
|
|
MeSetupStorage.MeStateControl = 1;
|
|
} else {
|
|
goto Done;
|
|
}
|
|
|
|
Status = gBS->LocateProtocol (&gAmtWrapperProtocolGuid, NULL, (VOID **) &AmtWrapper);
|
|
if (!EFI_ERROR (Status)) {
|
|
MeSetupStorage.RemoteSessionActive = AmtWrapper->IsStorageRedirectionEnabled () ||
|
|
AmtWrapper->IsSolEnabled () ||
|
|
AmtWrapper->IsKvmEnabled ();
|
|
}
|
|
|
|
Status = HeciGetFwFeatureStateMsg (&CurrentFeatures);
|
|
if (!EFI_ERROR (Status)) {
|
|
MeSetupStorage.MngState = !!CurrentFeatures.Fields.Amt;
|
|
MeSetupStorage.PttState = !!CurrentFeatures.Fields.PTT;
|
|
}
|
|
|
|
Status = HeciGetUserCapabilitiesState (&UserCapabilities);
|
|
if (!EFI_ERROR (Status)) {
|
|
MeSetupStorage.AmtState = !!UserCapabilities.Fields.Amt;
|
|
}
|
|
|
|
MeFwSts4.ul = HeciPciSegmentRead32 (R_ME_HFS_4);
|
|
if (MeFwSts4.ul != 0xFFFFFFFF) {
|
|
MeSetupStorage.TpmDeactivate = (UINT8) MeFwSts4.r.dTpm12Deactivated;
|
|
}
|
|
|
|
//
|
|
// Skip Local Firmware update if it is not Consumer sku or not in normal mode
|
|
//
|
|
Size = sizeof (ME_SETUP);
|
|
Status = gRT->GetVariable (L"MeSetup", &gMeSetupVariableGuid, NULL, &Size, &mMeSetup);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = HeciGetFwUpdateState (&FwUpdateState);
|
|
if (!EFI_ERROR (Status)) {
|
|
MeSetupStorage.FwUpdEnabled = FwUpdateState;
|
|
}
|
|
|
|
if (mMeSetup.MeImageType == IntelMeCorporateFw) {
|
|
//
|
|
// FIPS feature
|
|
//
|
|
Status = HeciGetFipsMode (&FipsModeData);
|
|
if (!EFI_ERROR (Status)) {
|
|
//[-start-201127-IB17510129-add]//
|
|
MeSetupStorage.FipsModeSelect = (UINT8)FipsModeData.FipsMode;
|
|
//[-end-201127-IB17510129-add]//
|
|
StringLength = sizeof (String);
|
|
Status = HiiLibGetString (mHiiHandle, FipsMode[!!FipsModeData.FipsMode], String, &StringLength);
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_ME_FW_FIPS_CURRENT_MODE_VALUE), L"%s", String);
|
|
InitString (
|
|
mHiiHandle,
|
|
STRING_TOKEN (STR_ME_FW_FIPS_CRYPTO_VER_VALUE),
|
|
L"%d.%d.%d.%d",
|
|
FipsModeData.CryptoVersion.Major,
|
|
FipsModeData.CryptoVersion.Minor,
|
|
FipsModeData.CryptoVersion.Build,
|
|
FipsModeData.CryptoVersion.Hotfix
|
|
);
|
|
}
|
|
|
|
//
|
|
// UPID Platform Id feature
|
|
//
|
|
Status = HeciGetPlatIdSupportedState (&MeSetupStorage.UpidSupport);
|
|
if (!EFI_ERROR (Status) && MeSetupStorage.UpidSupport == 1) {
|
|
Status = HeciGetUpidFeatureState (UpidFeaturePlatId, &MeSetupStorage.UpidState);
|
|
if (!EFI_ERROR (Status) && MeSetupStorage.UpidState == 1) {
|
|
Status = HeciGetUpidPlatformId (&OemPlatformIdType, OemPlatformId, CsmePlatformId);
|
|
if (!EFI_ERROR (Status)) {
|
|
//
|
|
// Update CSME Platform ID
|
|
//
|
|
ZeroMem (String, sizeof (String));
|
|
BinaryToHexString (String, CsmePlatformId, MAX_PLAT_ID_SIZE);
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_UPID_CSME_PLAT_ID_VALUE), L"%s", String);
|
|
|
|
//
|
|
// Update OEM Platform ID
|
|
//
|
|
ZeroMem (String, sizeof (String));
|
|
if (OemPlatformIdType == OemPlatIdTypePrintableString) {
|
|
AsciiStrToUnicodeStrS ((CHAR8 *)OemPlatformId, String, MAX_PLAT_ID_SIZE);
|
|
} else if (OemPlatformIdType == OemPlatIdTypeBinary) {
|
|
BinaryToHexString (String, OemPlatformId, MAX_PLAT_ID_SIZE);
|
|
}
|
|
if (OemPlatformIdType != OemPlatIdTypeNotSet) {
|
|
InitString (mHiiHandle, STRING_TOKEN (STR_UPID_OEM_PLAT_ID_VALUE), L"%s", String);
|
|
}
|
|
}
|
|
}
|
|
Status = HeciGetUpidOsControlState (UpidFeaturePlatId, &MeSetupStorage.UpidOsControlState);
|
|
}
|
|
|
|
}
|
|
|
|
Done:
|
|
if (ArbSvnInfo != NULL) {
|
|
FreePool (ArbSvnInfo);
|
|
}
|
|
Status = gRT->SetVariable (
|
|
L"MeSetupStorage",
|
|
&gMeSetupVariableGuid,
|
|
VariableAttr,
|
|
sizeof (ME_SETUP_STORAGE),
|
|
&MeSetupStorage
|
|
);
|
|
Status = gRT->SetVariable (
|
|
L"MeBackupStorage",
|
|
&gMeSetupVariableGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof (ME_SETUP_STORAGE),
|
|
&MeSetupStorage
|
|
);
|
|
|
|
// Since DEBUG() only allow max 12 format parameters, so call it twice.
|
|
DEBUG ((DEBUG_INFO, "MeExtractConfig %d %d %d %d %d %d %d %d %d %d %d %d",
|
|
MeSetupStorage.MngState,
|
|
MeSetupStorage.FwUpdEnabled,
|
|
MeSetupStorage.MeStateControl,
|
|
MeSetupStorage.AfterEoP,
|
|
MeSetupStorage.RemoteSessionActive,
|
|
MeSetupStorage.PttState,
|
|
MeSetupStorage.BootGuardSupport,
|
|
MeSetupStorage.MeasureBoot,
|
|
MeSetupStorage.TpmDeactivate,
|
|
MeSetupStorage.DelayedAuthenticationMode,
|
|
MeSetupStorage.FipsModeSelect,
|
|
MeSetupStorage.AmtState
|
|
));
|
|
DEBUG ((DEBUG_INFO, " %d %d %d %d\n",
|
|
MeSetupStorage.UpidSupport,
|
|
MeSetupStorage.UpidState,
|
|
MeSetupStorage.UpidOsControlState,
|
|
MeSetupStorage.ActiveLanInterface
|
|
));
|
|
|
|
}
|
|
|