edk2/DasharoModulePkg/Library/DasharoSystemFeaturesUiLib/DasharoSystemFeatures.c

/** @file
The Dasharo system features reference implementation

Copyright (c) 2022, 3mdeb Sp. z o.o. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause

**/

#include "DasharoSystemFeatures.h"
#include "DasharoOptions.h"

#include <Library/BaseLib.h>
#include <Library/DasharoVariablesLib.h>

#define PCH_OC_WDT_CTL				0x54
#define   PCH_OC_WDT_CTL_EN			BIT14
#define   PCH_OC_WDT_CTL_TOV_MASK		0x3FF

#define PRIVATE_DATA(field)   mDasharoSystemFeaturesPrivate.DasharoFeaturesData.field

// Feature state
STATIC CHAR16 mVarStoreName[] = L"FeaturesData";

STATIC DASHARO_SYSTEM_FEATURES_PRIVATE_DATA  mDasharoSystemFeaturesPrivate = {
  DASHARO_SYSTEM_FEATURES_PRIVATE_DATA_SIGNATURE,
  NULL,
  NULL,
  {
    DasharoSystemFeaturesExtractConfig,
    DasharoSystemFeaturesRouteConfig,
    DasharoSystemFeaturesCallback
  }
};

STATIC HII_VENDOR_DEVICE_PATH  mDasharoSystemFeaturesHiiVendorDevicePath = {
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_VENDOR_DP,
      {
        (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
        (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
      }
    },
    DASHARO_SYSTEM_FEATURES_GUID
  },
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    {
      (UINT8) (END_DEVICE_PATH_LENGTH),
      (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
    }
  }
};

/**
  This function uses the ACPI SDT protocol to locate an ACPI table.
  It is really only useful for finding tables that only have a single instance,
  e.g. FADT, FACS, MADT, etc.  It is not good for locating SSDT, etc.
  Matches are determined by finding the table with ACPI table that has
  a matching signature.

  @param[in] Signature           - Pointer to an ASCII string containing the OEM Table ID from the ACPI table header
  @param[in, out] Table          - Updated with a pointer to the table
  @param[in, out] Handle         - AcpiSupport protocol table handle for the table found
  @param[in, out] Version        - The version of the table desired

  @retval EFI_SUCCESS            - The function completed successfully.
  @retval EFI_NOT_FOUND          - Failed to locate AcpiTable.
  @retval EFI_NOT_READY          - Not ready to locate AcpiTable.
**/
EFI_STATUS
EFIAPI
LocateAcpiTableBySignature (
  IN      UINT32                        Signature,
  IN OUT  EFI_ACPI_DESCRIPTION_HEADER   **Table
  )
{
  EFI_STATUS                  Status;
  INTN                        Index;
  EFI_ACPI_TABLE_VERSION      Version;
  EFI_ACPI_DESCRIPTION_HEADER *OrgTable;
  EFI_ACPI_SDT_PROTOCOL       *SdtProtocol;
  UINTN                       Handle;

  Status = gBS->LocateProtocol (&gEfiAcpiSdtProtocolGuid, NULL, (VOID **)&SdtProtocol);
  if (EFI_ERROR (Status))
    return Status;

  ///
  /// Locate table with matching ID
  ///
  Version = 0;
  Index = 0;
  Handle = 0;
  do {
    Status = SdtProtocol->GetAcpiTable (
                            Index,
                            (EFI_ACPI_SDT_HEADER **)&OrgTable,
                            &Version,
                            &Handle
                            );
    if (Status == EFI_NOT_FOUND) {
      break;
    }
    ASSERT_EFI_ERROR (Status);
    Index++;
  } while (OrgTable->Signature != Signature);

  if (Status != EFI_NOT_FOUND) {
    *Table = AllocateCopyPool (OrgTable->Length, OrgTable);
    if (*Table == NULL)
      return EFI_OUT_OF_RESOURCES;
  }

  ///
  /// If we found the table, there will be no error.
  ///
  return Status;
}

/**
  Install Dasharo System Features Menu driver.

  @param ImageHandle          The image handle.
  @param SystemTable          The system table.

  @retval  EFI_SUCEESS        Installed Dasharo System Features.
  @retval  EFI_NOT_SUPPORTED  Dasharo System Features not supported.
  @retval  Other              Error.

**/
EFI_STATUS
EFIAPI
DasharoSystemFeaturesUiLibConstructor (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
)
{
  EFI_STATUS  Status;
  UINTN       BufferSize, VarSize;
  UINT8       DescriptorWriteable;

  if (!FixedPcdGetBool (PcdShowMenu))
    return EFI_SUCCESS;

  mDasharoSystemFeaturesPrivate.DriverHandle = NULL;
  Status = gBS->InstallMultipleProtocolInterfaces (
      &mDasharoSystemFeaturesPrivate.DriverHandle,
      &gEfiDevicePathProtocolGuid,
      &mDasharoSystemFeaturesHiiVendorDevicePath,
      &gEfiHiiConfigAccessProtocolGuid,
      &mDasharoSystemFeaturesPrivate.ConfigAccess,
      NULL
      );
  ASSERT_EFI_ERROR (Status);

  // Publish our HII data.
  mDasharoSystemFeaturesPrivate.HiiHandle = HiiAddPackages (
      &gDasharoSystemFeaturesGuid,
      mDasharoSystemFeaturesPrivate.DriverHandle,
      DasharoSystemFeaturesVfrBin,
      DasharoSystemFeaturesUiLibStrings,
      NULL
      );
  ASSERT (mDasharoSystemFeaturesPrivate.HiiHandle != NULL);

  // Set menu visibility
  PRIVATE_DATA(ShowSecurityMenu) = FixedPcdGetBool (PcdShowSecurityMenu);
  PRIVATE_DATA(ShowIntelMeMenu) = FixedPcdGetBool (PcdShowIntelMeMenu);
  PRIVATE_DATA(ShowUsbMenu) = FixedPcdGetBool (PcdShowUsbMenu);
  PRIVATE_DATA(ShowNetworkMenu) = FixedPcdGetBool (PcdShowNetworkMenu);
  PRIVATE_DATA(ShowChipsetMenu) = FixedPcdGetBool (PcdShowChipsetMenu);
  PRIVATE_DATA(ShowPowerMenu) = FixedPcdGetBool (PcdShowPowerMenu);
  PRIVATE_DATA(ShowPciMenu) = FixedPcdGetBool (PcdShowPciMenu);
  PRIVATE_DATA(ShowMemoryMenu) = FixedPcdGetBool (PcdShowMemoryMenu);
  PRIVATE_DATA(ShowSerialPortMenu) = FixedPcdGetBool (PcdShowSerialPortMenu);
  PRIVATE_DATA(ShowCpuMenu) = FixedPcdGetBool (PcdShowCpuMenu);
  // Set feature visibility
  PRIVATE_DATA(PowerMenuShowFanCurve) = FixedPcdGetBool (PcdPowerMenuShowFanCurve);
  PRIVATE_DATA(PowerMenuShowSleepType) = FixedPcdGetBool (PcdPowerMenuShowSleepType);
  PRIVATE_DATA(PowerMenuShowBatteryThresholds) = FixedPcdGetBool (PcdPowerMenuShowBatteryThresholds);
  PRIVATE_DATA(DasharoEnterprise) = FixedPcdGetBool (PcdDasharoEnterprise);
  PRIVATE_DATA(SecurityMenuShowIommu) = FixedPcdGetBool (PcdShowIommuOptions);
  PRIVATE_DATA(PciMenuShowResizeableBars) = FixedPcdGetBool (PcdPciMenuShowResizeableBars);
  PRIVATE_DATA(ShowSerialPortMenu) = FixedPcdGetBool (PcdShowSerialPortMenu);
  PRIVATE_DATA(SecurityMenuShowWiFiBt) = FixedPcdGetBool (PcdSecurityShowWiFiBtOption);
  PRIVATE_DATA(SecurityMenuShowCamera) = FixedPcdGetBool (PcdSecurityShowCameraOption);
  PRIVATE_DATA(MeHapAvailable) = FixedPcdGetBool (PcdIntelMeHapAvailable);
  PRIVATE_DATA(S3SupportExperimental) = FixedPcdGetBool (PcdS3SupportExperimental);
  PRIVATE_DATA(ShowLockBios) = FixedPcdGetBool (PcdShowLockBios);
  PRIVATE_DATA(ShowSmmBwp) = FixedPcdGetBool (PcdShowSmmBwp);
  PRIVATE_DATA(ShowFum) = FixedPcdGetBool (PcdShowFum);
  PRIVATE_DATA(ShowPs2Option) = FixedPcdGetBool (PcdShowPs2Option);
  PRIVATE_DATA(Have2ndUart) = FixedPcdGetBool (PcdHave2ndUart);
  PRIVATE_DATA(ShowCpuThrottlingThreshold) = FixedPcdGetBool (PcdShowCpuThrottlingThreshold);
  PRIVATE_DATA(ShowCpuCoreDisable) = FixedPcdGetBool(PcdShowCpuCoreDisable);
  PRIVATE_DATA(ShowCpuHyperThreading) = FixedPcdGetBool(PcdShowCpuHyperThreading);
  PRIVATE_DATA(WatchdogAvailable) = FixedPcdGetBool (PcdShowOcWdtOptions);
  PRIVATE_DATA(ShowPowerFailureState) = FixedPcdGet8 (PcdDefaultPowerFailureState) != POWER_FAILURE_STATE_HIDDEN;
  PRIVATE_DATA(HideFanCurveOff) = !FixedPcdGetBool (PcdPowerMenuShowFanCurveOffOption);
  PRIVATE_DATA(PowerMenuShowUsbPower) = FixedPcdGetBool (PcdPowerMenuShowUsbPowerOption);
  PRIVATE_DATA(PowerMenuShowDGPUPower) = FixedPcdGetBool (PcdPowerMenuShowDGPUPowerOption);
  PRIVATE_DATA(DgpuOnlyAvailable) = FixedPcdGetBool (PcdDgpuOnlyAvailable);
  PRIVATE_DATA(IntelMeMenuShowCbntStatus) = FixedPcdGetBool (PcdIntelMeMenuShowCbntStatus);
  PRIVATE_DATA(ShowMemorySpdProfile) = FixedPcdGetBool(PcdShowMemorySpdProfileOption);
  PRIVATE_DATA(ShowMemoryIbecc) = FixedPcdGetBool(PcdShowMemoryIbeccOption);
  PRIVATE_DATA(HaveDiskCapsules) = FixedPcdGetBool(PcdCapsuleOnDiskSupport);

  // HAP is only available if descriptor is not locked
  VarSize = sizeof (DescriptorWriteable);
  Status = gRT->GetVariable (
      DASHARO_VAR_DESCRIPTOR_WRITEABLE,
      &gDasharoSystemFeaturesGuid,
      NULL,
      &VarSize,
      &DescriptorWriteable
      );

  if (!EFI_ERROR(Status))
      PRIVATE_DATA(MeHapAvailable) &= DescriptorWriteable;

  // Ensure at least one option is visible in given menu (if enabled), otherwise hide it
  if (PRIVATE_DATA(ShowSecurityMenu))
    PRIVATE_DATA(ShowSecurityMenu) = FixedPcdGetBool (PcdDasharoEnterprise) ||
                                     FixedPcdGetBool (PcdShowIommuOptions) ||
                                     FixedPcdGetBool (PcdSecurityShowWiFiBtOption) ||
                                     FixedPcdGetBool (PcdSecurityShowCameraOption) ||
                                     FixedPcdGetBool (PcdShowLockBios) ||
                                     FixedPcdGetBool (PcdShowSmmBwp) ||
                                     FixedPcdGetBool (PcdShowFum);

  if (PRIVATE_DATA(ShowChipsetMenu))
    PRIVATE_DATA(ShowChipsetMenu) = FixedPcdGetBool (PcdShowOcWdtOptions) ||
                                    FixedPcdGetBool (PcdShowPs2Option);

  if (PRIVATE_DATA(ShowPowerMenu))
    PRIVATE_DATA(ShowPowerMenu) = FixedPcdGetBool (PcdPowerMenuShowFanCurve) ||
                                  FixedPcdGetBool (PcdPowerMenuShowSleepType) ||
                                  FixedPcdGetBool (PcdPowerMenuShowBatteryThresholds) ||
                                  FixedPcdGetBool (PcdShowCpuThrottlingThreshold) ||
                                  FixedPcdGetBool (PcdPowerMenuShowUsbPowerOption) ||
                                  FixedPcdGetBool (PcdPowerMenuShowDGPUPowerOption) ||
                                  (FixedPcdGet8 (PcdDefaultPowerFailureState) != POWER_FAILURE_STATE_HIDDEN);

  if (PRIVATE_DATA(ShowCpuMenu))
    PRIVATE_DATA(ShowCpuMenu) = FixedPcdGetBool(PcdShowCpuCoreDisable) ||
                                FixedPcdGetBool(PcdShowCpuHyperThreading);

  if (PRIVATE_DATA(ShowMemoryMenu))
    PRIVATE_DATA(ShowMemoryMenu) = FixedPcdGetBool(PcdShowMemorySpdProfileOption) ||
                                   FixedPcdGetBool(PcdShowMemoryIbeccOption);

  GetCpuInfo(&PRIVATE_DATA(BigCoreMaxCount),
             &PRIVATE_DATA(SmallCoreMaxCount),
             &PRIVATE_DATA(HybridCpuArchitecture),
             &PRIVATE_DATA(HyperThreadingSupported));

  if (!PRIVATE_DATA(HybridCpuArchitecture))
    PRIVATE_DATA(CoreMaxCount) = PRIVATE_DATA(BigCoreMaxCount);

#define LOAD_VAR(var, field) do {                                               \
    BufferSize = sizeof (PRIVATE_DATA(field));                                  \
    Status = gRT->GetVariable (                                                 \
        (var),                                                                  \
        &gDasharoSystemFeaturesGuid,                                            \
        NULL,                                                                   \
        &BufferSize,                                                            \
        &PRIVATE_DATA(field)                                                    \
        );                                                                      \
    if (EFI_ERROR (Status))                                                     \
      PRIVATE_DATA(field) = _Generic(PRIVATE_DATA(field),                       \
                                UINT8: DasharoGetVariableDefault(var).Uint8,    \
              DASHARO_WATCHDOG_CONFIG: DasharoGetVariableDefault(var).Watchdog, \
                 DASHARO_IOMMU_CONFIG: DasharoGetVariableDefault(var).Iommu,    \
               DASHARO_BATTERY_CONFIG: DasharoGetVariableDefault(var).Battery   \
    );                                                                          \
  } while (FALSE)

  LOAD_VAR (DASHARO_VAR_BATTERY_CONFIG, BatteryConfig);
  LOAD_VAR (DASHARO_VAR_BOOT_MANAGER_ENABLED, BootManagerEnabled);
  LOAD_VAR (DASHARO_VAR_CPU_THROTTLING_OFFSET, CpuThrottlingOffset);
  LOAD_VAR (DASHARO_VAR_ENABLE_CAMERA, EnableCamera);
  LOAD_VAR (DASHARO_VAR_ENABLE_WIFI_BT, EnableWifiBt);
  LOAD_VAR (DASHARO_VAR_FAN_CURVE_OPTION, FanCurveOption);
  LOAD_VAR (DASHARO_VAR_IOMMU_CONFIG, IommuConfig);
  LOAD_VAR (DASHARO_VAR_LOCK_BIOS, LockBios);
  LOAD_VAR (DASHARO_VAR_MEMORY_PROFILE, MemoryProfile);
  LOAD_VAR (DASHARO_VAR_IBECC, MemoryIbecc);
  LOAD_VAR (DASHARO_VAR_ME_MODE, MeMode);
  LOAD_VAR (DASHARO_VAR_NETWORK_BOOT, NetworkBoot);
  LOAD_VAR (DASHARO_VAR_OPTION_ROM_POLICY, OptionRomExecution);
  LOAD_VAR (DASHARO_VAR_POWER_FAILURE_STATE, PowerFailureState);
  LOAD_VAR (DASHARO_VAR_PS2_CONTROLLER, Ps2Controller);
  LOAD_VAR (DASHARO_VAR_RESIZEABLE_BARS_ENABLED, ResizeableBarsEnabled);
  LOAD_VAR (DASHARO_VAR_SERIAL_REDIRECTION, SerialPortRedirection);
  LOAD_VAR (DASHARO_VAR_SERIAL_REDIRECTION2, SerialPort2Redirection);
  LOAD_VAR (DASHARO_VAR_SLEEP_TYPE, SleepType);
  LOAD_VAR (DASHARO_VAR_SMM_BWP, SmmBwp);
  LOAD_VAR (DASHARO_VAR_USB_MASS_STORAGE, UsbMassStorage);
  LOAD_VAR (DASHARO_VAR_USB_STACK, UsbStack);
  LOAD_VAR (DASHARO_VAR_WATCHDOG, WatchdogConfig);
  LOAD_VAR (DASHARO_VAR_SMALL_CORE_ACTIVE_COUNT, SmallCoreActiveCount);
  LOAD_VAR (DASHARO_VAR_CORE_ACTIVE_COUNT, BigCoreActiveCount);
  LOAD_VAR (DASHARO_VAR_CORE_ACTIVE_COUNT, CoreActiveCount);
  LOAD_VAR (DASHARO_VAR_HYPER_THREADING, HyperThreading);
  LOAD_VAR (DASHARO_VAR_USB_PORT_POWER, UsbPortPower);
  LOAD_VAR (DASHARO_VAR_DGPU_STATE, DGPUState);

#undef LOAD_VAR

  PRIVATE_DATA(CpuThrottlingThreshold) =
    FixedPcdGet8(PcdCpuMaxTemperature) - PRIVATE_DATA(CpuThrottlingOffset);

  if (PRIVATE_DATA(HybridCpuArchitecture) &&
      PRIVATE_DATA(SmallCoreActiveCount) == 0 &&
      PRIVATE_DATA(BigCoreActiveCount) == 0) {
    /*
     * Invalid setting, which causes a brick, enable all cores. coreboot will
     * not allow to disable all cores and revert to default: enabling all
     * cores. Match the behavior here, so the variables are not stuck in this
     * state and showing variable state not matching the reality.
     */
    PRIVATE_DATA(SmallCoreActiveCount) = DASHARO_CPU_CORES_ENABLE_ALL;
    PRIVATE_DATA(BigCoreActiveCount) = DASHARO_CPU_CORES_ENABLE_ALL;

    if (FixedPcdGetBool(PcdShowCpuCoreDisable)) {
      gRT->SetVariable (
            DASHARO_VAR_SMALL_CORE_ACTIVE_COUNT,
            &gDasharoSystemFeaturesGuid,
            DasharoGetVariableAttributes (DASHARO_VAR_SMALL_CORE_ACTIVE_COUNT),
            sizeof (PRIVATE_DATA(SmallCoreActiveCount)),
            &PRIVATE_DATA(SmallCoreActiveCount)
            );
      gRT->SetVariable (
            DASHARO_VAR_CORE_ACTIVE_COUNT,
            &gDasharoSystemFeaturesGuid,
            DasharoGetVariableAttributes (DASHARO_VAR_CORE_ACTIVE_COUNT),
            sizeof (PRIVATE_DATA(BigCoreActiveCount)),
            &PRIVATE_DATA(BigCoreActiveCount)
            );
    }
  }

  return EFI_SUCCESS;
}

/**
  Unloads the application and its installed protocol.

  @param  ImageHandle     Handle that identifies the image to be unloaded.
  @param  SystemTable     The system table.

  @retval EFI_SUCCESS     The image has been unloaded.
**/
EFI_STATUS
EFIAPI
DasharoSystemFeaturesUiLibDestructor (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
)
{
  EFI_STATUS                  Status;

  Status = gBS->UninstallMultipleProtocolInterfaces (
      mDasharoSystemFeaturesPrivate.DriverHandle,
      &gEfiDevicePathProtocolGuid,
      &mDasharoSystemFeaturesHiiVendorDevicePath,
      &gEfiHiiConfigAccessProtocolGuid,
      &mDasharoSystemFeaturesPrivate.ConfigAccess,
      NULL
      );
  ASSERT_EFI_ERROR (Status);

  HiiRemovePackages (mDasharoSystemFeaturesPrivate.HiiHandle);

  return EFI_SUCCESS;
}

/**
  This function allows a caller to extract the current configuration for one
  or more named elements from the target driver.


  @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
  @param Request         A null-terminated Unicode string in <ConfigRequest> format.
  @param Progress        On return, points to a character in the Request string.
                         Points to the string's null terminator if request was successful.
                         Points to the most recent '&' before the first failing name/value
                         pair (or the beginning of the string if the failure is in the
                         first name/value pair) if the request was not successful.
  @param Results         A null-terminated Unicode string in <ConfigAltResp> format which
                         has all values filled in for the names in the Request string.
                         String to be allocated by the called function.

  @retval  EFI_SUCCESS            The Results is filled with the requested values.
  @retval  EFI_OUT_OF_RESOURCES   Not enough memory to store the results.
  @retval  EFI_INVALID_PARAMETER  Request is illegal syntax, or unknown name.
  @retval  EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.

**/
EFI_STATUS
EFIAPI
DasharoSystemFeaturesExtractConfig (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  CONST EFI_STRING                       Request,
  OUT EFI_STRING                             *Progress,
  OUT EFI_STRING                             *Results
  )
{
  EFI_STATUS                            Status;
  DASHARO_SYSTEM_FEATURES_PRIVATE_DATA  *Private;
  UINTN                                 BufferSize;
  EFI_STRING                            ConfigRequestHdr;
  EFI_STRING                            ConfigRequest;
  UINTN                                 Size;

  if (Progress == NULL || Results == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  *Progress = Request;
  if (Request != NULL &&
      !HiiIsConfigHdrMatch (Request, &gDasharoSystemFeaturesGuid, mVarStoreName)) {
    return EFI_NOT_FOUND;
  }

  Private = DASHARO_SYSTEM_FEATURES_PRIVATE_DATA_FROM_THIS (This);

  BufferSize = sizeof (DASHARO_FEATURES_DATA);
  ConfigRequest = Request;
  if (Request == NULL || (StrStr (Request, L"OFFSET") == NULL)) {
    // Request has no request element, construct full request string.
    // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
    // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator.
    ConfigRequestHdr = HiiConstructConfigHdr (
        &gDasharoSystemFeaturesGuid,
        mVarStoreName,
        Private->DriverHandle
        );
    Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
    ConfigRequest = AllocateZeroPool (Size);
    ASSERT (ConfigRequest != NULL);
    UnicodeSPrint (
        ConfigRequest,
        Size,
        L"%s&OFFSET=0&WIDTH=%016LX",
        ConfigRequestHdr,
        (UINT64) BufferSize
        );
    FreePool (ConfigRequestHdr);
  }

  // Convert fields of binary structure to string representation.
  Status = gHiiConfigRouting->BlockToConfig (
      gHiiConfigRouting,
      ConfigRequest,
      (CONST UINT8 *) &Private->DasharoFeaturesData,
      BufferSize,
      Results,
      Progress
      );
  ASSERT_EFI_ERROR (Status);

  // Free config request string if it was allocated.
  if (ConfigRequest != Request) {
    FreePool (ConfigRequest);
  }

  if (Request != NULL && StrStr (Request, L"OFFSET") == NULL) {
    *Progress = Request + StrLen (Request);
  }

  return Status;
}

/**
  This function processes the results of changes in configuration.

  @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
  @param Configuration   A null-terminated Unicode string in <ConfigResp> format.
  @param Progress        A pointer to a string filled in with the offset of the most
                         recent '&' before the first failing name/value pair (or the
                         beginning of the string if the failure is in the first
                         name/value pair) or the terminating NULL if all was successful.

  @retval  EFI_SUCCESS            The Results is processed successfully.
  @retval  EFI_INVALID_PARAMETER  Configuration is NULL.
  @retval  EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.

**/
EFI_STATUS
EFIAPI
DasharoSystemFeaturesRouteConfig (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  CONST EFI_STRING                       Configuration,
  OUT EFI_STRING                             *Progress
  )
{
  EFI_STATUS                            Status;
  UINTN                                 BufferSize;
  DASHARO_SYSTEM_FEATURES_PRIVATE_DATA  *Private;
  DASHARO_FEATURES_DATA                 DasharoFeaturesData;
  DASHARO_FEATURES_DATA                 *PrivateData;

  if (Progress == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  *Progress = Configuration;
  if (Configuration == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  if (!HiiIsConfigHdrMatch (Configuration, &gDasharoSystemFeaturesGuid, mVarStoreName)) {
    return EFI_NOT_FOUND;
  }

  Private = DASHARO_SYSTEM_FEATURES_PRIVATE_DATA_FROM_THIS (This);
  PrivateData = &Private->DasharoFeaturesData;

  // Construct data structure from configuration string.
  BufferSize = sizeof (DasharoFeaturesData);
  Status = gHiiConfigRouting->ConfigToBlock (
      gHiiConfigRouting,
      Configuration,
      (UINT8 *) &DasharoFeaturesData,
      &BufferSize,
      Progress
      );
  ASSERT_EFI_ERROR (Status);

  if (PrivateData->HybridCpuArchitecture && FixedPcdGetBool (PcdShowCpuCoreDisable)) {
    if (DasharoFeaturesData.SmallCoreActiveCount == 0 && PrivateData->BigCoreMaxCount == 0)
      return EFI_INVALID_PARAMETER;

    if (DasharoFeaturesData.BigCoreActiveCount == 0 && PrivateData->SmallCoreMaxCount == 0)
      return EFI_INVALID_PARAMETER;
  }

  // Can use CompareMem() on structures instead of a per-field comparison as
  // long as they are packed.
#define STORE_VAR_IF(var, field, cond) do {                        \
    if (cond) {                                                    \
      if (CompareMem (&Private->DasharoFeaturesData.field,         \
                      &DasharoFeaturesData.field,                  \
                      sizeof (DasharoFeaturesData.field)) != 0) {  \
        Status = gRT->SetVariable (                                \
            (var),                                                 \
            &gDasharoSystemFeaturesGuid,                           \
            DasharoGetVariableAttributes (var),                    \
            sizeof (DasharoFeaturesData.field),                    \
            &DasharoFeaturesData.field                             \
            );                                                     \
        if (EFI_ERROR (Status)) {                                  \
          return Status;                                           \
        }                                                          \
      }                                                            \
    }                                                              \
  } while (FALSE)

  if (FixedPcdGetBool (PcdShowSecurityMenu)) {
      STORE_VAR_IF (DASHARO_VAR_BOOT_MANAGER_ENABLED, BootManagerEnabled, FixedPcdGetBool (PcdDasharoEnterprise));
      STORE_VAR_IF (DASHARO_VAR_ENABLE_CAMERA, EnableCamera, FixedPcdGetBool (PcdSecurityShowCameraOption));
      STORE_VAR_IF (DASHARO_VAR_ENABLE_WIFI_BT, EnableWifiBt, FixedPcdGetBool (PcdSecurityShowWiFiBtOption));
      STORE_VAR_IF (DASHARO_VAR_IOMMU_CONFIG, IommuConfig, FixedPcdGetBool (PcdShowIommuOptions));
      STORE_VAR_IF (DASHARO_VAR_LOCK_BIOS, LockBios, FixedPcdGetBool (PcdShowLockBios));
      STORE_VAR_IF (DASHARO_VAR_SMM_BWP, SmmBwp, FixedPcdGetBool (PcdShowSmmBwp));
  }

  if (FixedPcdGetBool (PcdShowMemoryMenu)) {
    STORE_VAR_IF (DASHARO_VAR_MEMORY_PROFILE, MemoryProfile, FixedPcdGetBool (PcdShowMemorySpdProfileOption));
    STORE_VAR_IF (DASHARO_VAR_IBECC, MemoryIbecc, FixedPcdGetBool (PcdShowMemoryIbeccOption));
  }

  STORE_VAR_IF (DASHARO_VAR_ME_MODE, MeMode, FixedPcdGetBool (PcdShowIntelMeMenu));
  STORE_VAR_IF (DASHARO_VAR_NETWORK_BOOT, NetworkBoot, FixedPcdGetBool (PcdShowNetworkMenu));

  if (FixedPcdGetBool (PcdShowPowerMenu)) {
    STORE_VAR_IF (DASHARO_VAR_SLEEP_TYPE, SleepType, FixedPcdGetBool (PcdPowerMenuShowSleepType));
    STORE_VAR_IF (DASHARO_VAR_POWER_FAILURE_STATE, PowerFailureState,
                  FixedPcdGet8 (PcdDefaultPowerFailureState) != POWER_FAILURE_STATE_HIDDEN);
    STORE_VAR_IF (DASHARO_VAR_FAN_CURVE_OPTION, FanCurveOption, FixedPcdGetBool (PcdPowerMenuShowFanCurve));
    STORE_VAR_IF (DASHARO_VAR_BATTERY_CONFIG, BatteryConfig, FixedPcdGetBool (PcdPowerMenuShowBatteryThresholds));
    STORE_VAR_IF (DASHARO_VAR_CPU_THROTTLING_OFFSET, CpuThrottlingOffset, FixedPcdGetBool (PcdShowCpuThrottlingThreshold));
    STORE_VAR_IF (DASHARO_VAR_USB_PORT_POWER, UsbPortPower, FixedPcdGetBool (PcdPowerMenuShowUsbPowerOption));
    STORE_VAR_IF (DASHARO_VAR_DGPU_STATE, DGPUState, FixedPcdGetBool (PcdPowerMenuShowDGPUPowerOption));
  }

  if (FixedPcdGetBool (PcdShowPciMenu)) {
    STORE_VAR_IF (DASHARO_VAR_OPTION_ROM_POLICY, OptionRomExecution, TRUE);
    STORE_VAR_IF (DASHARO_VAR_RESIZEABLE_BARS_ENABLED, ResizeableBarsEnabled, FixedPcdGetBool (PcdPciMenuShowResizeableBars));
  }

  if (FixedPcdGetBool (PcdShowSerialPortMenu)) {
    STORE_VAR_IF (DASHARO_VAR_SERIAL_REDIRECTION, SerialPortRedirection, TRUE);
    STORE_VAR_IF (DASHARO_VAR_SERIAL_REDIRECTION2, SerialPort2Redirection, FixedPcdGetBool (PcdHave2ndUart));
  }

  if (FixedPcdGetBool (PcdShowUsbMenu)) {
    STORE_VAR_IF (DASHARO_VAR_USB_MASS_STORAGE, UsbMassStorage, TRUE);
    STORE_VAR_IF (DASHARO_VAR_USB_STACK, UsbStack, TRUE);
  }

  if (FixedPcdGetBool (PcdShowChipsetMenu)) {
    STORE_VAR_IF (DASHARO_VAR_WATCHDOG, WatchdogConfig, FixedPcdGetBool (PcdShowOcWdtOptions));
    STORE_VAR_IF (DASHARO_VAR_PS2_CONTROLLER, Ps2Controller, FixedPcdGetBool (PcdShowPs2Option));
  }

  if (FixedPcdGetBool (PcdShowCpuMenu)) {
    STORE_VAR_IF (DASHARO_VAR_HYPER_THREADING, HyperThreading, FixedPcdGetBool (PcdShowCpuHyperThreading));

    if (PrivateData->HybridCpuArchitecture) {
      STORE_VAR_IF (DASHARO_VAR_SMALL_CORE_ACTIVE_COUNT, SmallCoreActiveCount, FixedPcdGetBool (PcdShowCpuCoreDisable));
      STORE_VAR_IF (DASHARO_VAR_CORE_ACTIVE_COUNT, BigCoreActiveCount, FixedPcdGetBool (PcdShowCpuCoreDisable));
    } else {
      // CoreActiveCount used for P-cores and non-hybrid CPU architectures to match FSP
      STORE_VAR_IF (DASHARO_VAR_CORE_ACTIVE_COUNT, CoreActiveCount, FixedPcdGetBool (PcdShowCpuCoreDisable));
    }

  }

#undef STORE_VAR

  Private->DasharoFeaturesData = DasharoFeaturesData;
  return EFI_SUCCESS;
}

/**
  This function is invoked if user selected a interactive opcode from Device Manager's
  Formset. If user toggles bios lock, the new value is saved to EFI variable.

  @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
  @param Action          Specifies the type of action taken by the browser.
  @param QuestionId      A unique value which is sent to the original exporting driver
                         so that it can identify the type of data to expect.
  @param Type            The type of value for the question.
  @param Value           A pointer to the data being sent to the original exporting driver.
  @param ActionRequest   On return, points to the action requested by the callback function.

  @retval  EFI_SUCCESS           The callback successfully handled the action.
  @retval  EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.

**/
EFI_STATUS
EFIAPI
DasharoSystemFeaturesCallback (
  IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
  IN  EFI_BROWSER_ACTION                     Action,
  IN  EFI_QUESTION_ID                        QuestionId,
  IN  UINT8                                  Type,
  IN  EFI_IFR_TYPE_VALUE                     *Value,
  OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
  )
{
  EFI_STATUS                                 Status;
  EFI_INPUT_KEY                              Key;
  DASHARO_SYSTEM_FEATURES_PRIVATE_DATA       *Private;
  CONST CHAR16                               *PressEnterMsg;
  CONST CHAR16                               *VariableLines[3];

  Status = EFI_SUCCESS;
  Private = DASHARO_SYSTEM_FEATURES_PRIVATE_DATA_FROM_THIS (This);

  switch (Action) {
  case EFI_BROWSER_ACTION_RETRIEVE:
    switch (QuestionId) {
    case CPU_THROTTLING_THRESHOLD_QUESTION_ID:
      /*
       * For some reason CpuMaxTemperature is zeroed when user changes CPU
       * throttling, exits PWR MGMT menu, goes to front page and goes back to
       * PWR MGMT menu again. It results in the negative throttling threshold
       * to be displayed. Always calculate the threshold based on PCD and
       * current throttling offset value.
       */
      Value->u8 = FixedPcdGet8(PcdCpuMaxTemperature) - Private->DasharoFeaturesData.CpuThrottlingOffset;
      break;
    case IBG_SACM_INFO_MSR_QUESTION_ID:
      Value->u64 = AsmReadMsr64(0x13A);
      break;
    case IBG_BOOT_STATUS_QUESTION_ID:
      Value->u64 = MmioRead64(0xFED300A0);
      break;
    case IBG_ACM_STATUS_QUESTION_ID:
      Value->u32 = MmioRead64(0xFED30328);
      break;
    case IBG_ACM_POLICY_STATUS_QUESTION_ID:
      Value->u64 = MmioRead64(0xFED30378);
      break;
    default:
      Status = EFI_UNSUPPORTED;
      break;
    }
    break;
  case EFI_BROWSER_ACTION_DEFAULT_STANDARD:
  case EFI_BROWSER_ACTION_DEFAULT_MANUFACTURING:
    {
      if (Value == NULL)
        return EFI_INVALID_PARAMETER;

      switch (QuestionId) {
      case NETWORK_BOOT_QUESTION_ID:
        Value->b = DasharoGetVariableDefault (DASHARO_VAR_NETWORK_BOOT).Boolean;
        break;
      case WATCHDOG_ENABLE_QUESTION_ID:
        Value->b = DasharoGetVariableDefault (DASHARO_VAR_WATCHDOG).Watchdog.WatchdogEnable;
        break;
      case WATCHDOG_TIMEOUT_QUESTION_ID:
        Value->u16 = DasharoGetVariableDefault (DASHARO_VAR_WATCHDOG).Watchdog.WatchdogTimeout;
        break;
      case POWER_FAILURE_STATE_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_POWER_FAILURE_STATE).Boolean;
        break;
      case OPTION_ROM_STATE_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_OPTION_ROM_POLICY).Uint8;
        break;
      case SERIAL_PORT_REDIR_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_SERIAL_REDIRECTION).Boolean;
        break;
      case SERIAL_PORT2_REDIR_QUESTION_ID:
        Value->b = DasharoGetVariableDefault (DASHARO_VAR_SERIAL_REDIRECTION2).Boolean;
        break;
      case BATTERY_START_THRESHOLD_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_BATTERY_CONFIG).Battery.StartThreshold;
        break;
      case BATTERY_STOP_THRESHOLD_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_BATTERY_CONFIG).Battery.StopThreshold;
        break;
      case INTEL_ME_MODE_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_ME_MODE).Uint8;
        break;
      case SLEEP_TYPE_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_SLEEP_TYPE).Uint8;
        break;
      case HYPER_THREADING_QUESTION_ID:
        Value->b = DasharoGetVariableDefault (DASHARO_VAR_HYPER_THREADING).Boolean;
        break;
      case CPU_THROTTLING_OFFSET_QUESTION_ID:
        Value->u8 = DasharoGetVariableDefault (DASHARO_VAR_CPU_THROTTLING_OFFSET).Uint8;
        break;
      default:
        Status = EFI_UNSUPPORTED;
        break;
      }
      break;
    }
  case EFI_BROWSER_ACTION_CHANGED:
    {
      if (QuestionId == FIRMWARE_UPDATE_MODE_QUESTION_ID) {
        if (!FixedPcdGetBool(PcdShowFum))
          return EFI_UNSUPPORTED;

        PressEnterMsg = L"Press ENTER to continue and reboot or ESC to cancel...";
        if (PcdGetBool (PcdFumAutoIpxeBoot)) {
          VariableLines[0] = L"DTS will be started automatically through iPXE, please";
          VariableLines[1] = L"make sure an Ethernet cable is connected before continuing.";
          VariableLines[2] = L"";
        } else {
          VariableLines[0] = PressEnterMsg;
          VariableLines[1] = L"";
          /* This terminates list of lines. */
          VariableLines[2] = NULL;
        }

        do {
          CreatePopUp (
            EFI_BLACK | EFI_BACKGROUND_RED,
            &Key,
            L"",
            L"You are about to enable Firmware Update Mode.",
            L"This will turn off all flash protection mechanisms",
            L"for the duration of the next boot.",
            L"",
            VariableLines[0],
            VariableLines[1],
            VariableLines[2],
            PressEnterMsg,
            L"",
            NULL
            );
        } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));

        if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
          Status = DasharoEnableFUM ();
          if (EFI_ERROR (Status)) {
            return Status;
          }
          gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
        }
      } else {
        Status = EFI_UNSUPPORTED;
      }
    }
    break;
  default:
    Status = EFI_UNSUPPORTED;
    break;
  }

  return Status;
}