/** @file
 Setup functions.

@copyright
  INTEL CONFIDENTIAL
  Copyright 2010 - 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 <SetupCallbackList.h>
#include <SetupCallbackExList.h>
#include <InitStringList.h>
#include <Protocol/HiiConfigRouting.h>
#include <Protocol/HiiConfigAccess.h>
#include <Protocol/HiiString.h>
#include <Protocol/HiiDatabase.h>
#include <Protocol/DevicePath.h>
#include <Protocol/DxeSmmReadyToLock.h>
#include <Protocol/CpuInfo.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/HiiLib.h>
#include <Library/PrintLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/HobLib.h>
#include <Library/IoLib.h>
#include <Library/DevicePathLib.h>
#include <Library/CpuPcieInfoFruLib.h>
#include <Guid/GlobalVariable.h>
#include <Guid/MdeModuleHii.h>

#include <CommonDefinitions.h>
#include <Library/BiosIdLib.h>
#include "SetupPrivate.h"
#include <CpuRegs.h>
#include <PlatformNvRamHookLib.h>
#include <Protocol/MePlatformGetResetType.h>
#include "PlatformBoardId.h"
#include <Library/PciSegmentLib.h>
#include <Library/GpioLib.h>
#include <Protocol/VariableLock.h>
#include <ITbtInfoHob.h>
#include <Library/ReportStatusCodeLib.h>
#include <Library/CpuPlatformLib.h>
#include <Register/SaRegsHostBridge.h>
#define GetSupportedLanguages(HiiHandle) HiiGetSupportedLanguages(HiiHandle)

#include <FspInfoHob.h>
#include <Library/PcdLib.h>

#if FixedPcdGetBool(PcdITbtEnable) == 1
#include <TcssDataHob.h>
#endif
#include <VmdInfoHob.h>
#include <Library/VmdInfoLib.h>
#include <Library/TccLib.h>
#include <Library/PchInfoLib.h>
#include <CpuDmiHob.h>
#include <PchDmiHob.h>

extern UINT8 SetupStrings[];
extern UINT8 MainBin[];
extern UINT8 AdvancedBin[];
extern UINT8 BootBin[];

GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN                         IsFirstBoot = FALSE;
GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN                         HiiUpdateAtSetupEnter = FALSE;
GLOBAL_REMOVE_IF_UNREFERENCED SYSTEM_ACCESS                   SystemAccess;
GLOBAL_REMOVE_IF_UNREFERENCED SA_SETUP                        mSaSetup;
GLOBAL_REMOVE_IF_UNREFERENCED ME_SETUP                        mMeSetup;
GLOBAL_REMOVE_IF_UNREFERENCED CPU_SETUP                       mCpuSetup;
GLOBAL_REMOVE_IF_UNREFERENCED PCH_SETUP                       mPchSetup;
GLOBAL_REMOVE_IF_UNREFERENCED SETUP_DATA                      mSetupData;
GLOBAL_REMOVE_IF_UNREFERENCED SETUP_VOLATILE_DATA             mSetupVolatileData;
GLOBAL_REMOVE_IF_UNREFERENCED EFI_HII_STRING_PROTOCOL         *gIfrLibHiiString = NULL;
GLOBAL_REMOVE_IF_UNREFERENCED EFI_HII_DATABASE_PROTOCOL       *gIfrLibHiiDatabase = NULL;
GLOBAL_REMOVE_IF_UNREFERENCED EFI_HII_CONFIG_ROUTING_PROTOCOL *mConfigRouting = NULL;
GLOBAL_REMOVE_IF_UNREFERENCED ME_PLATFORM_GET_RESET_TYPE_PROTOCOL mMePlatformGetResetType;

//
// Limited buffer size recommended by RFC4646 (4.3.  Length Considerations)
// (42 characters plus a NULL terminator)
//
#define RFC_3066_ENTRY_SIZE             (42 + 1)

typedef struct {
  EFI_HII_CONFIG_ACCESS_PROTOCOL Callback;
  UINT16 Class, SubClass;
} SETUP_CALLBACK;

typedef struct {
  EFI_GUID            FormSetGuid;
  UINT8               *IfrPack;
  UINT16              Class;
  UINT16              SubClass;
  EFI_HANDLE          DriverHandle;
} FORM_SET_INFO;

EFI_STATUS
EFIAPI
Callback (
  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
  );

VOID
EFIAPI
UpdateCallBack (
  CALLBACK_INFO *pCallBackFound
  );

CHAR8 *
EFIAPI
HiiLibGetBestLanguage (
  IN CHAR8        *SupportedLanguages,
  IN BOOLEAN      Iso639Language,
  ...
  );

VOID
InstallPlatfromReset (
  VOID
  );

/*
  Create and update DebugSetupVolatile Data
*/
extern
VOID
InitDebugSetupVolatileData (
  VOID
  );

extern
EFI_STATUS
EFIAPI
InitCpuMntrDefault (
  IN VOID
  );


/**
  This function would update the EC RAM 0x78[bit0] which represent EC CS DEBUG LED
  function.

  @param  CSEnable              Value to indicate the EC CS DEBUG LED enable or not.

  @retval EFI_SUCCESS           Set the value successfully.
  @retval Others                Fail due to EC read or write.

**/
EFI_STATUS
EFIAPI
EcUpdateCsLED (
  IN UINT8        CSEnable
  );

/**
  Update the Rtd3 setting base on the board type.

  @param[IN]      UINT8                   Rtd3Support,
  @param[IN][OUT] SETUP_DATA              *SetupData

  @retval EFI_SUCCESS             Successfully completed updates.
  @retval Others                  Fail to update.
**/
EFI_STATUS
EFIAPI
UpdateRtd3Setting (
  IN      UINT8               Rtd3Support,
  IN OUT  SETUP_DATA          *SetupData
  );

/**
This function updates the CPU DMI info.

@retval EFI_SUCCESS            if the reboot is not required.
**/
EFI_STATUS
EFIAPI
UpdateCpuDmiInfo (
  )
{
  EFI_STATUS                      Status;
  UINTN                           VariableSize;
  UINT32                          VariableAttributes;
  SETUP_DATA                      SetupData;
  CPU_DMI_HOB                     *CpuDmiInfoHob;
  UINT8                           Index;

  DEBUG ((EFI_D_VERBOSE, "Cpu Dmi: UpdateCpuDmiInfo\n"));

  VariableSize = sizeof (SETUP_DATA);
  Status = gRT->GetVariable (
                  L"Setup",
                  &gSetupVariableGuid,
                  &VariableAttributes,
                  &VariableSize,
                  &SetupData
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  CpuDmiInfoHob = (CPU_DMI_HOB *)GetFirstGuidHob (&gCpuDmiHobGuid);
  if (CpuDmiInfoHob == NULL) {
    return EFI_NOT_FOUND;
  }
    DEBUG ((EFI_D_INFO, "--------------Before DmiHweq = %x \n",SetupData.DmiHweq));

  for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "DmiGen4RtcoCpre = %x \n",SetupData.DmiGen4RtcoCpre[Index]));
    DEBUG ((EFI_D_INFO, "DmiGen4RtcoCpo = %x \n",SetupData.DmiGen4RtcoCpo[Index]));
  }
  if (SetupData.DmiHweq == 0x2) {
  DEBUG ((EFI_D_INFO, "DmiHweq = %x \n",SetupData.DmiHweq));
  for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "CmGen4 = %x \n",CpuDmiInfoHob->CmGen4[Index]));
    DEBUG ((EFI_D_INFO, "CpGen4 = %x \n",CpuDmiInfoHob->CpGen4[Index]));
    SetupData.DmiGen4RtcoCpo[Index]   = CpuDmiInfoHob->CmGen4[Index];
    SetupData.DmiGen4RtcoCpre[Index]  = CpuDmiInfoHob->CpGen4[Index];
  }

    Status = gRT->SetVariable (
                    L"Setup",
                    &gSetupVariableGuid,
                    VariableAttributes,
                    VariableSize,
                    &SetupData
                    );
    ASSERT_EFI_ERROR (Status);
  }
    DEBUG ((EFI_D_INFO, "--------------After DmiHweq = %x \n",SetupData.DmiHweq));
    for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "DmiGen4RtcoCpre = %x \n",SetupData.DmiGen4RtcoCpre[Index]));
    DEBUG ((EFI_D_INFO, "DmiGen4RtcoCpo = %x \n",SetupData.DmiGen4RtcoCpo[Index]));
  }
  return EFI_SUCCESS;
}
/**
This function updates the PCH DMI EQ info.

@retval EFI_SUCCESS            if the reboot is not required.
**/
EFI_STATUS
EFIAPI
UpdatePchDmiInfo (
  )
{
  EFI_STATUS                      Status;
  UINTN                           VariableSize;
  UINT32                          VariableAttributes;
  SETUP_DATA                      SetupData;
  PCH_DMI_HOB                     *PchDmiInfoHob;
  UINT8                           Index;

  DEBUG ((EFI_D_VERBOSE, "Pch Dmi: UpdatePchDmiInfo\n"));

  VariableSize = sizeof (SETUP_DATA);
  Status = gRT->GetVariable (
                  L"Setup",
                  &gSetupVariableGuid,
                  &VariableAttributes,
                  &VariableSize,
                  &SetupData
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
  DEBUG ((EFI_D_INFO, "--------------PCH Before DmiHweq = %x \n",SetupData.DmiHweq));

  PchDmiInfoHob = (PCH_DMI_HOB *)GetFirstGuidHob (&gPchDmiHobGuid);
  if (PchDmiInfoHob == NULL) {
    return EFI_NOT_FOUND;
  }
  for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpre = %x \n",SetupData.PchDmiGen3RtcoCpre[Index]));
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpo = %x \n",SetupData.PchDmiGen3RtcoCpo[Index]));
  }
  if (SetupData.DmiHweq == 0x2) {
  SetupData.DmiHweq = 0x1;
  DEBUG ((EFI_D_INFO, "DmiHweq = %x \n",SetupData.DmiHweq));
  for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpre = %x \n",PchDmiInfoHob->CmGen3[Index]));
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpo = %x \n",PchDmiInfoHob->CpGen3[Index]));
    SetupData.PchDmiGen3RtcoCpo[Index] = PchDmiInfoHob->CmGen3[Index];
    SetupData.PchDmiGen3RtcoCpre[Index]  = PchDmiInfoHob->CpGen3[Index];
  }

    Status = gRT->SetVariable (
                    L"Setup",
                    &gSetupVariableGuid,
                    VariableAttributes,
                    VariableSize,
                    &SetupData
                    );
    ASSERT_EFI_ERROR (Status);
  }
  DEBUG ((EFI_D_INFO, "--------------PCH After DmiHweq = %x \n",SetupData.DmiHweq));
  for (Index = 0; Index < 8; Index++) {
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpre = %x \n",SetupData.PchDmiGen3RtcoCpre[Index]));
    DEBUG ((EFI_D_INFO, "PchDmiGen3RtcoCpo = %x \n",SetupData.PchDmiGen3RtcoCpo[Index]));
  }
  return EFI_SUCCESS;
}

SETUP_CALLBACK MainCallbackProtocol = {{NULL,NULL,Callback},MAIN_FORM_SET_CLASS,0};
SETUP_CALLBACK AdvancedCallbackProtocol = {{NULL,NULL,Callback},ADVANCED_FORM_SET_CLASS,0};
SETUP_CALLBACK BootCallbackProtocol = {{NULL,NULL,Callback},BOOT_FORM_SET_CLASS,0};

CALLBACK_INFO SetupCallBack[] = {
  // Last field in every structure will be filled by the Setup
  { NULL, &MainCallbackProtocol.Callback, MAIN_FORM_SET_CLASS, 0, 0},
  { NULL, &AdvancedCallbackProtocol.Callback, ADVANCED_FORM_SET_CLASS, 0, 0},
  { NULL, &BootCallbackProtocol.Callback, BOOT_FORM_SET_CLASS, 0, 0},
};

FORM_SET_INFO SetupFormSets[] = {
  {MAIN_FORM_SET_GUID, MainBin, MAIN_FORM_SET_CLASS, 0, NULL},
  {ADVANCED_FORM_SET_GUID, AdvancedBin, ADVANCED_FORM_SET_CLASS, 0, NULL},
  {BOOT_FORM_SET_GUID, BootBin, BOOT_FORM_SET_CLASS, 0, NULL},
};

BOOLEAN FormsetVisible[] = {
  TRUE, //Main formset is always displayed
  SHOW_ADVANCED_FORMSET, //Advanced formset
  TRUE, //Boot formset is always displayed; the Boot Manager part is diabled because of the conflict with EDKII BDS' one
  TRUE
};

#define NUMBER_OF_FORMSETS (sizeof(SetupCallBack) / sizeof(CALLBACK_INFO))

#pragma pack(1)
typedef struct {
  VENDOR_DEVICE_PATH             VendorDevicePath;
  EFI_DEVICE_PATH_PROTOCOL       End;
} HII_VENDOR_DEVICE_PATH;
#pragma pack()

HII_VENDOR_DEVICE_PATH  mHiiVendorDevicePathTemplate = {
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_VENDOR_DP,
      {
        (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
        (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
      }
    },
    ADVANCED_FORM_SET_GUID
  },
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    {
      (UINT8) (END_DEVICE_PATH_LENGTH),
      (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
    }
  }
};

EFI_STATUS
LocateHiiStringProtocol (
  OUT  EFI_HII_STRING_PROTOCOL **HiiStrProtocol
  )
{
  EFI_STATUS Status;

  Status = EFI_SUCCESS;

  if (NULL == (*HiiStrProtocol)) {
    Status = gBS->LocateProtocol (
                    &gEfiHiiStringProtocolGuid,
                    NULL,
                    (VOID **) HiiStrProtocol
                    );
  }
  return Status;
}

EFI_STATUS
LocateHiiDataBaseProtocol (
  OUT EFI_HII_DATABASE_PROTOCOL **HiiDataBaseProtocol
  )
{
  EFI_STATUS Status;

  Status = EFI_SUCCESS;

  if (NULL == (*HiiDataBaseProtocol)) {
    Status = gBS->LocateProtocol (
                    &gEfiHiiDatabaseProtocolGuid,
                    NULL,
                    (VOID **) HiiDataBaseProtocol
                    );
  }
  return Status;
}

VOID
EFIAPI
InitString (
  EFI_HII_HANDLE HiiHandle,
  EFI_STRING_ID  StrRef,
  CHAR16         *sFormat,
  ...
  )
{
  CHAR16      StringBuffer[1024];
  VA_LIST     ArgList;
  CHAR8       PlatformLanguage[RFC_3066_ENTRY_SIZE];
  CHAR8       *SupportedLanguages;
  CHAR8       *BestLanguage;
  UINTN       Size;
  EFI_STATUS  Status;

  //
  // Get current language setting
  //
  Size = sizeof (PlatformLanguage);
  Status = gRT->GetVariable (
                  L"PlatformLang",
                  &gEfiGlobalVariableGuid,
                  NULL,
                  &Size,
                  PlatformLanguage
                  );
  if (EFI_ERROR (Status)) {
    AsciiStrCpyS (PlatformLanguage, sizeof (PlatformLanguage) / sizeof (CHAR8), (CHAR8 *) "en-US");
  }

  SupportedLanguages = GetSupportedLanguages (HiiHandle);
  if (SupportedLanguages == NULL) {
    //
    // No supported language.
    //
    return;
  }
  //
  // Get the best matching language from SupportedLanguages
  //
  BestLanguage = HiiLibGetBestLanguage (
                   SupportedLanguages,
                   FALSE,                                             // RFC 4646 mode
                   PlatformLanguage,                                  // Highest priority
                   SupportedLanguages,                                // Lowest priority
                   NULL
                   );

  //
  // Construct string value.
  //
  VA_START(ArgList,sFormat);
  UnicodeVSPrint (StringBuffer,sizeof(StringBuffer),sFormat,ArgList);
  VA_END(ArgList);

  //
  // Set string
  //
  if (NULL == gIfrLibHiiString) {
    Status = gBS->LocateProtocol (
                    &gEfiHiiStringProtocolGuid,
                    NULL,
                    (VOID **) &gIfrLibHiiString
                    );
    if (EFI_ERROR (Status)) {
      return;
    }
  }

  gIfrLibHiiString->SetString (
                     gIfrLibHiiString,
                     HiiHandle,
                     StrRef,
                     BestLanguage,
                     StringBuffer,
                     NULL
                     );

  if (SupportedLanguages != NULL) {
    FreePool (SupportedLanguages);
  }

  if (BestLanguage != NULL) {
    FreePool (BestLanguage);
  }
}


EFI_STATUS
GetFspInformation (
  IN OUT FSP_INFO_HOB **FspInfo
  )
{
  EFI_HOB_GUID_TYPE  *GuidHob;

  GuidHob = NULL;
  GuidHob = GetFirstGuidHob (&gFspInfoGuid);
  ASSERT (GuidHob != NULL);
  if (GuidHob == NULL) {
    return EFI_NOT_FOUND;
  }

  *FspInfo = (FSP_INFO_HOB *) GET_GUID_HOB_DATA (GuidHob);

  return EFI_SUCCESS;
}

VOID
GetFspReleaseTime (
  IN OUT FSP_INFO_HOB  *FspInfo,
  CHAR16               FspReleaseDate[17]
  )
{
  FspReleaseDate[0] = FspInfo->TimeStamp[8];
  FspReleaseDate[1] = FspInfo->TimeStamp[9];
  FspReleaseDate[2] = (CHAR16) ((UINT8) (':'));
  FspReleaseDate[3] = FspInfo->TimeStamp[10];
  FspReleaseDate[4] = FspInfo->TimeStamp[11];
  FspReleaseDate[5] = ' ';
  FspReleaseDate[6] = FspInfo->TimeStamp[4];
  FspReleaseDate[7] = FspInfo->TimeStamp[5];
  FspReleaseDate[8] = (CHAR16) ((UINT8) ('/'));
  FspReleaseDate[9] = FspInfo->TimeStamp[6];
  FspReleaseDate[10] = FspInfo->TimeStamp[7];
  FspReleaseDate[11] = (CHAR16) ((UINT8) ('/'));
  FspReleaseDate[12] = FspInfo->TimeStamp[0];
  FspReleaseDate[13] = FspInfo->TimeStamp[1];
  FspReleaseDate[14] = FspInfo->TimeStamp[2];
  FspReleaseDate[15] = FspInfo->TimeStamp[3];
  FspReleaseDate[16] = (CHAR16) ((UINT8) ('\0'));
}


EFI_STATUS InitMain(EFI_HII_HANDLE HiiHandle, UINT16 Class)
{
  EFI_STATUS                        Status;
  CHAR16                            Version[100];         //Assuming that strings are < 100 UCHAR
  CHAR16                            ReleaseDate[100];     //Assuming that strings are < 100 UCHAR
  CHAR16                            ReleaseTime[100];     //Assuming that strings are < 100 UCHAR
  CHAR16                            FspReleaseTime[17];
  FSP_INFO_HOB                      *FspInfo;

  if (Class != MAIN_FORM_SET_CLASS) {
    return EFI_SUCCESS;
  }

  ///////////////// BIOS /////////////////////////////////////
  if (gST->FirmwareVendor)
    InitString(
      HiiHandle,STRING_TOKEN(STR_BIOS_VENDOR_VALUE),
      L"%s", gST->FirmwareVendor
    );
  else
    InitString(
      HiiHandle,STRING_TOKEN(STR_BIOS_VENDOR_VALUE),
      L"%s", L"Intel "
    );

  InitString(
    HiiHandle,STRING_TOKEN(STR_BIOS_SILICON_VERSION_VALUE),
    L"%02x.%02x.%02x.%02x",
    PcdGet8 (PcdSiliconInitVersionMajor),
    PcdGet8 (PcdSiliconInitVersionMinor),
    PcdGet8 (PcdSiliconInitVersionRevision),
    PcdGet8 (PcdSiliconInitVersionBuild)
  );

  Status = GetBiosVersionDateTime (Version, ReleaseDate, ReleaseTime);
  if (!EFI_ERROR (Status)) {
    InitString(
      HiiHandle,STRING_TOKEN(STR_BIOS_VERSION_VALUE),
      L"%s", Version
    );
    InitString(
      HiiHandle,STRING_TOKEN(STR_BIOS_DATE_VALUE),
      L"%s %s", ReleaseTime, ReleaseDate
    );
  }

  //
  // Update FSP Information.
  //
  Status = GetFspInformation (&FspInfo);
  if (! EFI_ERROR (Status)) {
    InitString (
      HiiHandle,STRING_TOKEN (STR_FSP_VERSION_VALUE),
      L"%02x.%02x.%02x.%02x",
      FspInfo->SiliconInitVersionMajor,
      FspInfo->FspVersionMinor,
      FspInfo->FspVersionRevision,
      FspInfo->FspVersionBuild
      );

    InitString (
      HiiHandle,STRING_TOKEN (STR_RC_VERSION_VALUE),
      L"%02x.%02x.%02x.%02x",
      FspInfo->SiliconInitVersionMajor,
      FspInfo->SiliconInitVersionMinor,
      FspInfo->SiliconInitVersionRevision,
      FspInfo->SiliconInitVersionBuild
      );

    GetFspReleaseTime (FspInfo,FspReleaseTime);
    InitString (
      HiiHandle,STRING_TOKEN (STR_BUILD_DATE_VALUE),
      L"%s", FspReleaseTime
      );

    if(PcdGet8 (PcdFspModeSelection) == 0) {
      InitString (
        HiiHandle,STRING_TOKEN (STR_FSP_MODE_VALUE),
        L"Dispatch Mode"
        );
    } else {
      InitString (
        HiiHandle,STRING_TOKEN (STR_FSP_MODE_VALUE),
        L"API Mode"
        );
    }
  } else {
    DEBUG ((DEBUG_ERROR, "Get FSP Information Failed : %r\n", Status));
  }

  return EFI_SUCCESS;
}

typedef EFI_STATUS (INIT_FUNCTION)(EFI_HII_HANDLE HiiHandle, UINT16 Class);

extern INIT_FUNCTION INIT_LIST EndOfInitList;
#if FixedPcdGetBool(PcdNct677FPresent) == 1
extern INIT_FUNCTION NctUpdateHwmonString;
#endif

INIT_FUNCTION* InitList[] = { InitMain, INIT_LIST
#if FixedPcdGetBool(PcdNct677FPresent) == 1
                              NctUpdateHwmonString,
#endif
                              NULL };


VOID InitParts(EFI_HII_HANDLE HiiHandle, UINT16 Class)
{
  UINTN i;
  for(i=0; InitList[i]; i++) InitList[i](HiiHandle,Class);
}

VOID
EFIAPI
InitStrings (
  IN EFI_EVENT Event,
  IN VOID *Context
  )
{
  EFI_STATUS Status;
  UINTN      Index;
  VOID       *Protocol;

  if (!HiiUpdateAtSetupEnter) {
    Status = gBS->LocateProtocol(
                    &gBdsAllDriversConnectedProtocolGuid,
                    NULL,
                    &Protocol
                    );
    if (EFI_ERROR (Status)) {
      return ;
    }
  } else {
    Status = gBS->LocateProtocol(
                    &gSetupEnterGuid,
                    NULL,
                    &Protocol
                    );
    if (EFI_ERROR (Status)) {
      return ;
    }
  }

  for (Index = 0; Index < NUMBER_OF_FORMSETS; Index ++) {
    if (SetupCallBack[Index].HiiHandle == NULL) {
      continue;
    }

    InitParts(SetupCallBack[Index].HiiHandle, SetupCallBack[Index].Class);
  }

  gBS->CloseEvent (Event);
}

VOID
InstallHiiResources (
  VOID
  )
{
  CALLBACK_INFO          *pCallBackFound;
  UINTN                  Index;
  EFI_HII_HANDLE         HiiHandle;
  EFI_HANDLE             DriverHandle;
  EFI_STATUS             Status;
  HII_VENDOR_DEVICE_PATH *mHiiVendorDevicePath;

  pCallBackFound = NULL;

  for (Index = 0; Index < NUMBER_OF_FORMSETS; Index++) {
    pCallBackFound = &SetupCallBack[Index];
    UpdateCallBack (pCallBackFound);
    DEBUG ((DEBUG_INFO, " InstallHiiResources: UpdateCallBack was done.\n"));

    DriverHandle = NULL;
    mHiiVendorDevicePath = NULL;
    mHiiVendorDevicePath = AllocateCopyPool (sizeof (HII_VENDOR_DEVICE_PATH), &mHiiVendorDevicePathTemplate);
    ASSERT (mHiiVendorDevicePath != NULL);
    if (mHiiVendorDevicePath == NULL) {
      return;
    }
    mHiiVendorDevicePath->VendorDevicePath.Guid = SetupFormSets[Index].FormSetGuid;

    //
    // Install Config Access protocol
    //
    Status = gBS->InstallMultipleProtocolInterfaces (
                    &DriverHandle,
                    &gEfiDevicePathProtocolGuid,
                    mHiiVendorDevicePath,
                    &gEfiHiiConfigAccessProtocolGuid,
                    pCallBackFound->pFormCallback,
                    NULL
                    );
    ASSERT_EFI_ERROR (Status);

    //
    // Publish our HII data
    //
    HiiHandle = HiiAddPackages (
                   &SetupFormSets[Index].FormSetGuid,
                   DriverHandle,
                   SetupStrings,
                   SetupFormSets[Index].IfrPack,
                   NULL
                   );
    ASSERT (HiiHandle != NULL);
    DEBUG ((DEBUG_INFO, " InstallHiiResources: HiiPackages was added.\n"));

    if (pCallBackFound) {
      pCallBackFound->HiiHandle = HiiHandle;
    }

    pCallBackFound = NULL;
  }

}

VOID
EFIAPI
BackupSetupDataAndCheckForPassword (
  IN EFI_EVENT Event,
  IN VOID *Context
  )
{
  UINTN                VariableSize;
  SA_SETUP             SaSetup;
  ME_SETUP             MeSetup;
  CPU_SETUP            CpuSetup;
  PCH_SETUP            PchSetup;
  SI_SETUP             SiSetup;
  SETUP_DATA           SetupData;
  EFI_STATUS           Status;
  VOID                 *Protocol;

  Status = gBS->LocateProtocol (
                  &gSetupEnterGuid,
                  NULL,
                  &Protocol
                  );
  if (EFI_ERROR (Status)) {
    return ;
  }

  //
  // Signal check for password
  //
  REPORT_STATUS_CODE (
    EFI_PROGRESS_CODE,
    (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_USER_SETUP)
    );

  VariableSize = sizeof (SETUP_DATA);
  Status = gRT->GetVariable (
                  L"Setup",
                  &gSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &SetupData
                  );
  ASSERT_EFI_ERROR (Status);

  Status = gRT->SetVariable (
                  L"ColdReset",
                  &gSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &SetupData
                  );
  ASSERT_EFI_ERROR (Status);

  VariableSize = sizeof (SA_SETUP);
  Status = gRT->GetVariable (
                  L"SaSetup",
                  &gSaSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &SaSetup
                  );
  ASSERT_EFI_ERROR (Status);

  Status = gRT->SetVariable (
                  L"SaColdReset",
                  &gSaSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &SaSetup
                  );
  ASSERT_EFI_ERROR (Status);

  VariableSize = sizeof (ME_SETUP);
  Status = gRT->GetVariable (
                  L"MeSetup",
                  &gMeSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &MeSetup
                  );
  ASSERT_EFI_ERROR (Status);

  Status = gRT->SetVariable (
                  L"MeColdReset",
                  &gMeSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &MeSetup
                  );
  ASSERT_EFI_ERROR (Status);

  VariableSize = sizeof (CPU_SETUP);
  Status = gRT->GetVariable (
                  L"CpuSetup",
                  &gCpuSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &CpuSetup
                  );
  ASSERT_EFI_ERROR (Status);

  Status = gRT->SetVariable (
                  L"CpuColdReset",
                  &gCpuSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &CpuSetup
                  );
  ASSERT_EFI_ERROR (Status);

  VariableSize = sizeof (PCH_SETUP);
  Status = gRT->GetVariable (
                  L"PchSetup",
                  &gPchSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &PchSetup
                  );
  ASSERT_EFI_ERROR (Status);

  Status = gRT->SetVariable (
                  L"PchColdReset",
                  &gPchSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &PchSetup
                  );
  ASSERT_EFI_ERROR (Status);

  VariableSize = sizeof (SI_SETUP);
  Status = gRT->GetVariable(
                  L"SiSetup",
                  &gSiSetupVariableGuid,
                  NULL,
                  &VariableSize,
                  &SiSetup
                  );
  ASSERT_EFI_ERROR(Status);

  Status = gRT->SetVariable(
                  L"SiColdReset",
                  &gSiSetupVariableGuid,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  VariableSize,
                  &SiSetup
                  );
  ASSERT_EFI_ERROR(Status);

  gBS->CloseEvent (Event);
}

VOID
SetupCallback (
  IN EFI_EVENT   Event,
  IN VOID        *Context
  )
{
  static BOOLEAN         ResourcesLoaded = FALSE;
  UINT32                 Index;
  EFI_STATUS             Status;
  UINTN                  VariableSize;
  SETUP_DATA             SetupData;
  VOID                   *SetupRegistration;
  VOID                   *BdsDriverConnectRegistration;
  EFI_BOOT_MODE          BootMode;

  if (!ResourcesLoaded) {
    ResourcesLoaded = TRUE;

    Status = gBS->LocateProtocol (
                    &gEfiHiiConfigRoutingProtocolGuid,
                    NULL,
                    (VOID **) &mConfigRouting
                    );
    ASSERT_EFI_ERROR (Status);
    DEBUG ((DEBUG_INFO, " SetupCallback: EfiHiiConfigRoutingProtocolGuid was found.\n"));

    InitCpuMntrDefault();

    InstallHiiResources();
    DEBUG ((DEBUG_INFO, " SetupCallback: HiiResources was installed.\n"));

    VariableSize = sizeof(SETUP_DATA);
    Status = gRT->GetVariable (
                    L"Setup",
                    &gSetupVariableGuid,
                    NULL,
                    &VariableSize,
                    &SetupData
                    );
    ASSERT_EFI_ERROR (Status);
    DEBUG ((DEBUG_INFO, " SetupCallback: SetupVar was found.\n"));

    if (!EFI_ERROR(Status) && (SetupData.FastBoot)) {
      BootMode = GetBootModeHob();
      DEBUG ((DEBUG_INFO, " BootModeHob was found.\n"));

      if ((SetupData.SkipHIIUpdate) &&
         ((BootMode == BOOT_WITH_MINIMAL_CONFIGURATION) ||
          (BootMode == BOOT_ON_S4_RESUME) ||
          (BootMode == BOOT_ASSUMING_NO_CONFIGURATION_CHANGES))) {
        HiiUpdateAtSetupEnter = TRUE;
      }
    }

    if (!HiiUpdateAtSetupEnter) {
      EfiCreateProtocolNotifyEvent(
         &gBdsAllDriversConnectedProtocolGuid,
         TPL_CALLBACK,
         InitStrings,
         NULL,
         &BdsDriverConnectRegistration
         );
    } else {
      EfiCreateProtocolNotifyEvent(
         &gSetupEnterGuid,
         TPL_CALLBACK,
         InitStrings,
         NULL,
         &SetupRegistration
         );
    }

    EfiCreateProtocolNotifyEvent(
       &gSetupEnterGuid,
       TPL_CALLBACK,
       BackupSetupDataAndCheckForPassword,
       NULL,
       &SetupRegistration
       );
  }

  for (Index = 0; Index < NUMBER_OF_FORMSETS; Index++) {
    if (!FormsetVisible[Index] && SetupCallBack[Index].HiiHandle != NULL) {
      gIfrLibHiiDatabase->RemovePackageList (gIfrLibHiiDatabase, SetupCallBack[Index].HiiHandle);
      SetupCallBack[Index].HiiHandle = NULL;
    }
  }

  DEBUG ((DEBUG_INFO, " SetupCallback was done.\n"));
}

EFI_STATUS
EFIAPI
SetupEntry (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
#if ( FORCE_USER_TO_SETUP_ON_FIRST_BOOT || FORCE_USER_TO_SETUP_IF_BOOT_WITH_DEFAULT )
  static UINT32 BootFlow = BOOT_FLOW_CONDITION_FIRST_BOOT;
#endif

  UINTN                           Size;
  EFI_STATUS                      Status;
  UINT32                          RegEAX, RegEBX, RegECX, RegEDX;
  SA_SETUP                        *pSaSetup;
  PCH_SETUP                       *pPchSetup;
  CPU_SETUP_VOLATILE_DATA         CpuSetupVolData;
  CPU_SETUP_VOLATILE_DATA         *pCpuSetupVolData;
  UINT8                           InitSetupFlag;
  OS_PROFILE                      OsProfileData;
  UINTN                           OsProfileSize;
  UINT32                          OsProfileAttr;
  UINT32                          VariableAttributes;
  UINT32                          SetupVolVarAttr;
  UINT32                          CpuSetupVolVarAttr;
  UINT32                          TbtSetupVolatileDataAttr;
  TBT_SETUP_VOLATILE_DATA         TbtSetupVolatileVar;
  TBT_SETUP_VOLATILE_DATA         *pTbtSetupVolatileVar;
  UINT32                          InitSetupVolVarAttr;
  EFI_HANDLE                      DriverHandle;
  EDKII_VARIABLE_LOCK_PROTOCOL    *VariableLockProtocol;
  UINT64                          HbPciD0F0RegBase;
  UINT8                           Index;
  CPU_INFO_PROTOCOL               *CpuInfo;
  CPU_INFO                        *BigCoreInfo;
  BOOLEAN                         SetupItbtDataModified;
#if FixedPcdGetBool(PcdITbtEnable) == 1
  TCSS_DATA_HOB                   *TcssHob;
  UINT8                           TcssCpuXhciPortSupportMap;
#endif
  VMD_INFO_HOB                    *VmdInfoHob;
  BOOLEAN                         SetupDTBTDpMuxDataModified;
#if FixedPcdGetBool(PcdITbtEnable) == 1
  TcssHob = NULL;
  TcssCpuXhciPortSupportMap = PcdGet8 (PcdCpuXhciPortSupportMap); // Get Board Capability Map set Cpu Xhci Port.
#endif

  VmdInfoHob = NULL;
  CpuInfo    = NULL;

  ZeroMem (&mSetupData, sizeof(mSetupData));
  ZeroMem (&mSetupVolatileData, sizeof(mSetupVolatileData));
  ZeroMem (&SystemAccess, sizeof(SystemAccess));
  ZeroMem (&TbtSetupVolatileVar, sizeof(TbtSetupVolatileVar));

  // Init gIfrLibHiiString
  Status = LocateHiiStringProtocol (&gIfrLibHiiString);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  // Init gIfrLibHiiDatabase
  Status = LocateHiiDataBaseProtocol (&gIfrLibHiiDatabase);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  // Locate CPU Info Protocol.
  Status = gBS->LocateProtocol (&gCpuInfoProtocolGuid, NULL, (VOID **) &CpuInfo);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Located CpuInfo Protocol Status = %r\n", Status));
    return Status;
  }

  //
  // Get SetupVolatileData Variable
  //
  Size = sizeof (SETUP_VOLATILE_DATA);
  Status = gRT->GetVariable (
                  L"SetupVolatileData",
                  &gSetupVariableGuid,
                  &SetupVolVarAttr,
                  &Size,
                  &mSetupVolatileData
                  );
  ASSERT_EFI_ERROR (Status);

  CpuSetupVolVarAttr = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
  Size = sizeof (CPU_SETUP_VOLATILE_DATA);
  Status = gRT->GetVariable (
                  L"CpuSetupVolatileData",
                  &gCpuSetupVariableGuid,
                  &CpuSetupVolVarAttr,
                  &Size,
                  &CpuSetupVolData
                  );
  if (Status == EFI_NOT_FOUND) {
    Status = gRT->SetVariable (
                    L"CpuSetupVolatileData",
                    &gCpuSetupVariableGuid,
                    CpuSetupVolVarAttr,
                    sizeof (CpuSetupVolData),
                    &CpuSetupVolData
                    );
    ASSERT_EFI_ERROR (Status);
  }

  TbtSetupVolatileDataAttr = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
  Size = sizeof(TBT_SETUP_VOLATILE_DATA);
  Status = gRT->GetVariable(
                  L"TbtSetupVolatileData",
                  &gSetupVariableGuid,
                  &TbtSetupVolatileDataAttr,
                  &Size,
                  &TbtSetupVolatileVar
                  );
  if (Status == EFI_NOT_FOUND) {
    Status = gRT->SetVariable(
                    L"TbtSetupVolatileData",
                    &gSetupVariableGuid,
                    TbtSetupVolatileDataAttr,
                    sizeof(TbtSetupVolatileVar),
                    &TbtSetupVolatileVar
                    );
     ASSERT_EFI_ERROR(Status);
  }

  InitDebugSetupVolatileData ();

  //
  // Get VTd status
  //
  HbPciD0F0RegBase = PCI_SEGMENT_LIB_ADDRESS (SA_SEG_NUM, SA_MC_BUS, SA_MC_DEV, SA_MC_FUN, 0);
  mSetupVolatileData.VTdAvailable = (PciSegmentRead32 (HbPciD0F0RegBase + 0xe4) & BIT23) ? 0 : 1;

  //
  // Set SetupVolatileData Variable
  //
  Status = gRT->SetVariable (
                  L"SetupVolatileData",
                  &gSetupVariableGuid,
                  SetupVolVarAttr,
                  sizeof (mSetupVolatileData),
                  &mSetupVolatileData
                  );
  ASSERT_EFI_ERROR (Status);

  //
  // Check whether first boot.
  //
  InitSetupVolVarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
  Size = sizeof (InitSetupFlag);
  Status = gRT->GetVariable (L"InitSetupVariable", &gSetupVariableGuid, &InitSetupVolVarAttr, &Size, &InitSetupFlag);
  if (Status == EFI_NOT_FOUND) {
    IsFirstBoot   = TRUE;
    InitSetupFlag = 1;
    gRT->SetVariable (
           L"InitSetupVariable",
           &gSetupVariableGuid,
           InitSetupVolVarAttr,
           sizeof (InitSetupFlag),
           &InitSetupFlag
           );
  }

  //
  // Check Setup Variable.
  // Setup Variable should always exist, because post build will create the default setup variable.
  //

  Size = sizeof (mSetupData);
  Status = gRT->GetVariable(L"Setup", &gSetupVariableGuid, &VariableAttributes, &Size, &mSetupData);
  ASSERT_EFI_ERROR (Status);
  if (!EFI_ERROR (Status)) {
    //
    // Update EC CS debug light value
    //
    Status = EcUpdateCsLED (mSetupData.CSDebugLightEC);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_INFO, "Fail to initialize the EC CS Debug light 0x78[bit0], Status: %r\n", Status));
    }

    //
    // Update Rtd3 setting
    //
    Status = UpdateRtd3Setting (mSetupData.Rtd3Support, &mSetupData);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_INFO, "Fail to update the RTD3 setting: %r!\n", Status));
    } else {
      Status = gRT->SetVariable (L"Setup", &gSetupVariableGuid, VariableAttributes, Size, &mSetupData);
      ASSERT_EFI_ERROR (Status);
    }

    //
    // DTBT Dp Mux
    //
    SetupDTBTDpMuxDataModified = FALSE;

    if (PcdGet32 (PcdDpMuxGpio)) {
      if (mSetupData.DTbtDpInSupport != 1){
        mSetupData.DTbtDpInSupport = 1;
        SetupDTBTDpMuxDataModified = TRUE;
        DEBUG ((EFI_D_INFO, "Setup dTBT DpMux Data is Modified\n"));
      }
    }

    SetupItbtDataModified = FALSE;
#if FixedPcdGetBool(PcdITbtEnable) == 1
    //
    // Get status of each iTBT PCIe RP is enabled or not.
    //
    TcssHob = (TCSS_DATA_HOB *)GetFirstGuidHob (&gTcssHobGuid);
    if (TcssHob != NULL) {
      for (Index = 0; Index < MAX_ITBT_PCIE_PORT; Index++) {
        //
        // Check each iTBT PCIe RP is enabled or not.
        //
        if (mSetupData.ITbtPcieRootPortSupported[Index] != TcssHob->TcssData.ItbtPcieRpEn[Index]) {
          mSetupData.ITbtPcieRootPortSupported[Index] = TcssHob->TcssData.ItbtPcieRpEn[Index];
          SetupItbtDataModified = TRUE;
        }
      }
    }
#endif
    if (SetupItbtDataModified || SetupDTBTDpMuxDataModified) {
      gRT->SetVariable (
          L"Setup",
          &gSetupVariableGuid,
          VariableAttributes,
          sizeof (mSetupData),
          &mSetupData
          );
      DEBUG ((EFI_D_INFO, "Save the data back to mSetupData\n"));
    }
  } else {
    DEBUG ((EFI_D_INFO, "mSetupData is NULL\n"));
  }

  Size = sizeof (mMeSetup);
  Status = gRT->GetVariable(L"MeSetup", &gMeSetupVariableGuid, &VariableAttributes, &Size, &mMeSetup);
  ASSERT_EFI_ERROR (Status);

  Size = sizeof (mCpuSetup);
  Status = gRT->GetVariable(L"CpuSetup", &gCpuSetupVariableGuid, &VariableAttributes, &Size, &mCpuSetup);
  ASSERT_EFI_ERROR (Status);
  //
  // Update CpuSetup info according the CPU info.
  //
  BigCoreInfo = &(CpuInfo->CpuInfo[BIG_CORE]);
  mCpuSetup.CoreVfPointCount = BigCoreInfo->CoreVfPointCount;
  mCpuSetup.RingVfPointCount = BigCoreInfo->RingVfPointCount;

  gRT->SetVariable (
         L"CpuSetup",
         &gCpuSetupVariableGuid,
         VariableAttributes,
         sizeof (mCpuSetup),
         &mCpuSetup
         );

  Size = sizeof (mPchSetup);
  Status = gRT->GetVariable(L"PchSetup", &gPchSetupVariableGuid, &VariableAttributes, &Size, &mPchSetup);
  ASSERT_EFI_ERROR (Status);

  //
  // Check whether exist the "SystemAccess" info, if not exist, initialize it to Zero.
  //
  Size = sizeof (SystemAccess);
  Status = gRT->GetVariable(L"SystemAccess", &gSystemAccessGuid, NULL, &Size, &SystemAccess);

  //
  // Need to lock SystemAccess variable to prevent changing by some malicious software
  //
  Status = gBS->LocateProtocol (&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLockProtocol);
  if (!EFI_ERROR (Status)) {
    Status = VariableLockProtocol->RequestToLock (
                                     VariableLockProtocol,
                                     L"SystemAccess",
                                     &gSystemAccessGuid
                                     );
    if (EFI_ERROR (Status)) {
      DEBUG ((EFI_D_ERROR, "System Access Variable unable to be locked: Status = %r\n", Status));
    }
  }

  DEBUG ((DEBUG_INFO, " SetupEntry: Setup variables were found\n"));

  //
  // Update SaSetup variables
  //
  Size = sizeof (mSaSetup);
  Status = gRT->GetVariable(L"SaSetup", &gSaSetupVariableGuid, &VariableAttributes, &Size, &mSaSetup);
  ASSERT_EFI_ERROR (Status);
  if (!EFI_ERROR (Status)) {
    pSaSetup = (SA_SETUP *) &mSaSetup;
    pSaSetup->GtDid = PciSegmentRead16 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 2, 0, 2));

    if (IsAdlPch ()
       ) {
      UpdateCpuDmiInfo ();
      UpdatePchDmiInfo ();
    }

    // VMD: Check if VMD is supported
    if (IsVmdSupported() == TRUE) { // VMD is supported
      pSaSetup->VmdSupported = 1;
      //
      // Update VMD Volatile variables
      //
      VmdInfoHob = (VMD_INFO_HOB *) GetFirstGuidHob (&gVmdInfoHobGuid);
      if (VmdInfoHob != NULL) {
        for (Index=0; Index < VMD_MAX_DEVICES; ++Index) {
          pSaSetup->VmdPortPresent[Index] = VmdInfoHob->VmdPortInfo.PortInfo[Index].DeviceDetected;
          pSaSetup->VmdPort[Index]        = VmdInfoHob->VmdPortInfo.PortInfo[Index].PortEn;
          // Also update the device and func
          pSaSetup->VmdPortDev[Index]     = VmdInfoHob->VmdPortInfo.PortInfo[Index].RpDev;
          pSaSetup->VmdPortFunc[Index]    = VmdInfoHob->VmdPortInfo.PortInfo[Index].RpFunc;
        }
        DEBUG ((EFI_D_INFO, "Vmd: Printing updated setup info\n"));
        for (Index=0; Index < VMD_MAX_DEVICES; ++Index) {
          if (pSaSetup->VmdPortPresent[Index]) { //print only if device is discovered
            DEBUG ((EFI_D_INFO, "Vmd For Rp %d VmdPortPresent is %d  VmdPort-En is %d  VmdPortDev is %d  VmdPortFunc is %d\n",
              Index, pSaSetup->VmdPortPresent[Index], pSaSetup->VmdPort[Index], pSaSetup->VmdPortDev[Index], pSaSetup->VmdPortFunc[Index] ));
          }
        }
      } else {
        DEBUG ((EFI_D_INFO, "Vmd Info Hob not found\n"));
      }
    }

    for (Index = 0; Index < GetMaxCpuPciePortNum(); Index++) {
      pSaSetup->PcieRootPortMultiVcSupported[Index] = (UINT8) IsRpMultiVc(Index);
    }

    gRT->SetVariable (
           L"SaSetup",
           &gSaSetupVariableGuid,
           VariableAttributes,
           sizeof (mSaSetup),
           &mSaSetup
           );
  }


  //
  // Update CPU Volatile variables
  //
  AsmCpuid(1, &RegEAX, &RegEBX, &RegECX, &RegEDX);

  pPchSetup = (PCH_SETUP *) &mPchSetup;
  pCpuSetupVolData = (CPU_SETUP_VOLATILE_DATA *) &CpuSetupVolData;
  pTbtSetupVolatileVar = (TBT_SETUP_VOLATILE_DATA *)&TbtSetupVolatileVar;
  pPchSetup->RootPortDid = PciSegmentRead16 (PCI_SEGMENT_LIB_ADDRESS (0, 0, 0, 0, 2)); // @todo: fix RP DID.
  pCpuSetupVolData->CpuFamilyModel = (UINT16) RegEAX & 0x3FF0;  // @todo to use the CPU lib instead of reading the registers directly
  pCpuSetupVolData->CpuExtendedFamilyModel = (UINT16) ((RegEAX >> 16) & 0x0FFF);
  pCpuSetupVolData->CpuStepping = (UINT8) RegEAX & 0xF;

  pCpuSetupVolData->EdramSupported = IsEdramEnable ();

  pCpuSetupVolData->TccSupported = IsTccSku();

  pTbtSetupVolatileVar->ITbtRootPortsNumber = PcdGet8 (PcdITbtRootPortNumber);
  pTbtSetupVolatileVar->DTbtContollersNumber = PcdGet8 (PcdDTbtControllerNumber);

#if FixedPcdGetBool(PcdITbtEnable) == 1
  for (Index = 0; Index < MAX_TCSS_USB3_PORTS; Index++) {
    pTbtSetupVolatileVar->TcssCpuXhciPortSupport[Index] = ((TcssCpuXhciPortSupportMap >> Index) & BIT0);
  }
#endif

  gRT->SetVariable (
         L"PchSetup",
         &gPchSetupVariableGuid,
         VariableAttributes,
         sizeof (mPchSetup),
         &mPchSetup
         );

  gRT->SetVariable (
         L"CpuSetupVolatileData",
         &gCpuSetupVariableGuid,
         CpuSetupVolVarAttr,
         sizeof (CpuSetupVolData),
         &CpuSetupVolData
         );
  Status = gRT->SetVariable(
                  L"TbtSetupVolatileData",
                  &gSetupVariableGuid,
                  TbtSetupVolatileDataAttr,
                  sizeof(TbtSetupVolatileVar),
                  &TbtSetupVolatileVar
                  );

  DEBUG ((DEBUG_INFO, " SetupEntry: Setup variables were updated\n"));

  //
  // Always install HII resources
  //
  SetupCallback(NULL, NULL);

  DEBUG ((DEBUG_INFO, " SetupEntry: SetupCallback was done.\n"));

  Status = gIfrLibHiiDatabase->GetPackageListHandle (gIfrLibHiiDatabase, SetupCallBack[1].HiiHandle, &DriverHandle);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, " SetupEntry: Not found driver handle for SetupCallBack[1]\n"));
    return EFI_INVALID_PARAMETER;
  }

#if FORCE_USER_TO_SETUP_ON_FIRST_BOOT
  if (IsFirstBoot) {
    Status = gRT->GetVariable(L"BootFlow", &gBootFlow, NULL, &Size, NULL);
    if (Status == EFI_NOT_FOUND) {
    ClearDiagnosticStatus ();
      return gRT->SetVariable (
                    L"BootFlow",
                    &gBootFlow,
                    EFI_VARIABLE_BOOTSERVICE_ACCESS,
                    sizeof(BootFlow),
                    &BootFlow
                    );
    }
  }
#endif

  DEBUG ((DEBUG_INFO, " SetupEntry: HII resources was installed\n"));
  //
  // Register platform reset callback
  //
  InstallPlatfromReset ();

  DEBUG ((DEBUG_INFO, " SetupEntry: PlatformReset was installed\n"));

#if FORCE_USER_TO_SETUP_IF_BOOT_WITH_DEFAULT
  if (IsChecksumBad() || (BOOT_WITH_DEFAULT_SETTINGS == GetBootModeHob())) {
    DEBUG ((DEBUG_INFO, "Secondary NvRam bad, force user to enter setup.\n"));
  ClearDiagnosticStatus ();

  if (!IsChecksumBad()) {
      //
      // Setup configuration is changed to default, system reset is required
      //
      gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
    }
    return gRT->SetVariable (
                  L"BootFlow",
                  &gBootFlow,
                  EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  sizeof(BootFlow),
                  &BootFlow
                  );
  }
#endif

  // OS Profile related update:
  // Need to check this in every boot
  OsProfileSize = sizeof (OS_PROFILE);
  Status = gRT->GetVariable(
                  L"OsProfile",
                  &gOsProfileGuid,
                  &OsProfileAttr,
                  &OsProfileSize,
                  &OsProfileData
                  );
  DEBUG((DEBUG_INFO, "\n In Setup Entry, GetVariable OsProfile Status = %r, attributes = %X \n", Status, OsProfileAttr));

  if (EFI_ERROR(Status)) {
    if (Status == EFI_NOT_FOUND) {
      OsProfileData.OsProfile = OsNone;
      OsProfileData.PrevOs = OsNone;
      OsProfileAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
      OsProfileSize = sizeof (OS_PROFILE);

      Status = gRT->SetVariable (
                      L"OsProfile",
                      &gOsProfileGuid,
                      OsProfileAttr,
                      OsProfileSize,
                      &OsProfileData
                      );
      DEBUG(( DEBUG_INFO, "SetVariable OsProfile Status = %r \n", Status ));
    }
  } else if ( OsProfileData.PrevOs != OsProfileData.OsProfile ) {
    OsProfileData.PrevOs = OsProfileData.OsProfile;

    Status = gRT->SetVariable (
                    L"OsProfile",
                    &gOsProfileGuid,
                    OsProfileAttr,
                    OsProfileSize,
                    &OsProfileData
                    );
    DEBUG(( DEBUG_INFO, "SetVariable OsProfile Status = %r \n", Status ));
  }

  return EFI_SUCCESS;
}

typedef VOID (UPDATE_ITEM)(EFI_HII_HANDLE HiiHandle, UINT16 Class, UINT16 SubClass, UINT16 Key);

typedef struct {
  UINT16 Class, SubClass, Key;
  UPDATE_ITEM *UpdateItem;
} SETUP_ITEM_CALLBACK;

#define ITEM_CALLBACK(Class,Subclass,Key,Callback) Callback
extern UPDATE_ITEM SETUP_ITEM_CALLBACK_LIST EndOfList;
#undef ITEM_CALLBACK

#define ITEM_CALLBACK(Class,Subclass,Key,Callback) {Class,Subclass,Key,&Callback}
SETUP_ITEM_CALLBACK SetupItemCallback[] = { SETUP_ITEM_CALLBACK_LIST {0,0,0,NULL} };
#undef ITEM_CALLBACK

typedef EFI_STATUS (UPDATE_ITEM_EX)(CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, EFI_BROWSER_ACTION Action, EFI_QUESTION_ID KeyValue, UINT8 Type, EFI_IFR_TYPE_VALUE *Value, EFI_BROWSER_ACTION_REQUEST *ActionRequest );

typedef struct {
  UINT16 Class, SubClass, Key;
  UPDATE_ITEM_EX *UpdateItemEx;
} SETUP_ITEM_CALLBACK_EX;

#define ITEM_CALLBACK_EX(Class,Subclass,Key,Callback) Callback
extern UPDATE_ITEM_EX SETUP_ITEM_CALLBACK_LIST_EX EndOfListEx;
#undef ITEM_CALLBACK_EX

#define ITEM_CALLBACK_EX(Class,Subclass,Key,Callback) {Class,Subclass,Key,&Callback}
SETUP_ITEM_CALLBACK_EX SetupItemCallbackEx[] = { SETUP_ITEM_CALLBACK_LIST_EX {0,0,0,NULL} };
#undef ITEM_CALLBACK_EX

EFI_STATUS
EFIAPI
Callback (
  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
  )
{
  UINTN                  Index;
  SETUP_CALLBACK         *pCallback = (SETUP_CALLBACK*)This;
  EFI_STATUS             Status = EFI_UNSUPPORTED;
  SETUP_ITEM_CALLBACK    *pItemCallback = SetupItemCallback;
  SETUP_ITEM_CALLBACK_EX *pItemCallbackEx = SetupItemCallbackEx;

  for (Index = 0; Index < NUMBER_OF_FORMSETS; Index++) {
    if (SetupCallBack[Index].Class == pCallback->Class && SetupCallBack[Index].SubClass == pCallback->SubClass)
    {
      while (pItemCallback->UpdateItem)
      {
        if (pItemCallback->Class == pCallback->Class &&
            pItemCallback->SubClass == pCallback->SubClass &&
            pItemCallback->Key == KeyValue) {
          pItemCallback->UpdateItem (
                           SetupCallBack[Index].HiiHandle,
                           pItemCallback->Class,
                           pItemCallback->SubClass,
                           KeyValue
                           );
        }
        pItemCallback++;
      }
      while (pItemCallbackEx->UpdateItemEx)
      {
        if (pItemCallbackEx->Class == pCallback->Class &&
            pItemCallbackEx->SubClass == pCallback->SubClass &&
            pItemCallbackEx->Key == KeyValue) {
          Status = pItemCallbackEx->UpdateItemEx(This, Action, KeyValue, Type, Value, ActionRequest);
        }
        pItemCallbackEx++;
      }
    }
  }
  return Status;
}