TcgConfigImpl.c

Go to the documentation of this file.

 
#include "TcgConfigImpl.h"
 
CHAR16  mTcgStorageName[] = L"TCG_CONFIGURATION";
 
TCG_CONFIG_PRIVATE_DATA  mTcgConfigPrivateDateTemplate = {
  TCG_CONFIG_PRIVATE_DATA_SIGNATURE,
  {
    TcgExtractConfig,
    TcgRouteConfig,
    TcgCallback
  }
};
 
HII_VENDOR_DEVICE_PATH  mTcgHiiVendorDevicePath = {
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_VENDOR_DP,
      {
        (UINT8)(sizeof (VENDOR_DEVICE_PATH)),
        (UINT8)((sizeof (VENDOR_DEVICE_PATH)) >> 8)
      }
    },
    TCG_CONFIG_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
GetTpmState (
  IN  EFI_TCG_PROTOCOL  *TcgProtocol,
  OUT BOOLEAN           *TpmEnable   OPTIONAL,
  OUT BOOLEAN           *TpmActivate OPTIONAL
  )
{
  EFI_STATUS           Status;
  TPM_RSP_COMMAND_HDR  *TpmRsp;
  UINT32               TpmSendSize;
  TPM_PERMANENT_FLAGS  *TpmPermanentFlags;
  UINT8                CmdBuf[64];
 
  ASSERT (TcgProtocol != NULL);
 
  //
  // Get TPM Permanent flags (TpmEnable, TpmActivate)
  //
  if ((TpmEnable != NULL) || (TpmActivate != NULL)) {
    TpmSendSize           = sizeof (TPM_RQU_COMMAND_HDR) + sizeof (UINT32) * 3;
    *(UINT16 *)&CmdBuf[0] = SwapBytes16 (TPM_TAG_RQU_COMMAND);
    *(UINT32 *)&CmdBuf[2] = SwapBytes32 (TpmSendSize);
    *(UINT32 *)&CmdBuf[6] = SwapBytes32 (TPM_ORD_GetCapability);
 
    *(UINT32 *)&CmdBuf[10] = SwapBytes32 (TPM_CAP_FLAG);
    *(UINT32 *)&CmdBuf[14] = SwapBytes32 (sizeof (TPM_CAP_FLAG_PERMANENT));
    *(UINT32 *)&CmdBuf[18] = SwapBytes32 (TPM_CAP_FLAG_PERMANENT);
 
    Status = TcgProtocol->PassThroughToTpm (
                            TcgProtocol,
                            TpmSendSize,
                            CmdBuf,
                            sizeof (CmdBuf),
                            CmdBuf
                            );
    TpmRsp = (TPM_RSP_COMMAND_HDR *)&CmdBuf[0];
    if (EFI_ERROR (Status) || (TpmRsp->tag != SwapBytes16 (TPM_TAG_RSP_COMMAND)) || (TpmRsp->returnCode != 0)) {
      return EFI_DEVICE_ERROR;
    }
 
    TpmPermanentFlags = (TPM_PERMANENT_FLAGS *)&CmdBuf[sizeof (TPM_RSP_COMMAND_HDR) + sizeof (UINT32)];
 
    if (TpmEnable != NULL) {
      *TpmEnable = (BOOLEAN) !TpmPermanentFlags->disable;
    }
 
    if (TpmActivate != NULL) {
      *TpmActivate = (BOOLEAN) !TpmPermanentFlags->deactivated;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TcgExtractConfig (
  IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
  IN CONST EFI_STRING                      Request,
  OUT EFI_STRING                           *Progress,
  OUT EFI_STRING                           *Results
  )
{
  EFI_STATUS               Status;
  TCG_CONFIG_PRIVATE_DATA  *PrivateData;
  EFI_STRING               ConfigRequestHdr;
  EFI_STRING               ConfigRequest;
  BOOLEAN                  AllocatedRequest;
  UINTN                    Size;
  BOOLEAN                  TpmEnable;
  BOOLEAN                  TpmActivate;
 
  if ((Progress == NULL) || (Results == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *Progress = Request;
  if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gTcgConfigFormSetGuid, mTcgStorageName)) {
    return EFI_NOT_FOUND;
  }
 
  ConfigRequestHdr = NULL;
  ConfigRequest    = NULL;
  AllocatedRequest = FALSE;
  Size             = 0;
 
  PrivateData = TCG_CONFIG_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
  //
  PrivateData->Configuration->TpmOperation = PHYSICAL_PRESENCE_NO_ACTION;
 
  //
  // Get current TPM state.
  //
  if (PrivateData->TcgProtocol != NULL) {
    Status = GetTpmState (PrivateData->TcgProtocol, &TpmEnable, &TpmActivate);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    PrivateData->Configuration->TpmEnable   = TpmEnable;
    PrivateData->Configuration->TpmActivate = TpmActivate;
  }
 
  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 (&gTcgConfigFormSetGuid, mTcgStorageName, PrivateData->DriverHandle);
    Size             = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
    ConfigRequest    = AllocateZeroPool (Size);
    ASSERT (ConfigRequest != NULL);
    AllocatedRequest = TRUE;
    UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, sizeof (TCG_CONFIGURATION));
    FreePool (ConfigRequestHdr);
  }
 
  Status = gHiiConfigRouting->BlockToConfig (
                                gHiiConfigRouting,
                                ConfigRequest,
                                (UINT8 *)PrivateData->Configuration,
                                sizeof (TCG_CONFIGURATION),
                                Results,
                                Progress
                                );
  //
  // Free the allocated config request string.
  //
  if (AllocatedRequest) {
    FreePool (ConfigRequest);
  }
 
  //
  // Set Progress string to the original request string.
  //
  if (Request == NULL) {
    *Progress = NULL;
  } else if (StrStr (Request, L"OFFSET") == NULL) {
    *Progress = Request + StrLen (Request);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
TcgRouteConfig (
  IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL  *This,
  IN CONST EFI_STRING                      Configuration,
  OUT EFI_STRING                           *Progress
  )
{
  EFI_STATUS         Status;
  UINTN              BufferSize;
  TCG_CONFIGURATION  TcgConfiguration;
 
  if ((Configuration == NULL) || (Progress == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  *Progress = Configuration;
  if (!HiiIsConfigHdrMatch (Configuration, &gTcgConfigFormSetGuid, mTcgStorageName)) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Convert <ConfigResp> to buffer data by helper function ConfigToBlock()
  //
  BufferSize = sizeof (TCG_CONFIGURATION);
  Status     = gHiiConfigRouting->ConfigToBlock (
                                    gHiiConfigRouting,
                                    Configuration,
                                    (UINT8 *)&TcgConfiguration,
                                    &BufferSize,
                                    Progress
                                    );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
SavePpRequest (
  IN UINT8  PpRequest
  )
{
  EFI_STATUS             Status;
  UINTN                  DataSize;
  EFI_PHYSICAL_PRESENCE  PpData;
 
  //
  // Save TPM command to variable.
  //
  DataSize = sizeof (EFI_PHYSICAL_PRESENCE);
  Status   = gRT->GetVariable (
                    PHYSICAL_PRESENCE_VARIABLE,
                    &gEfiPhysicalPresenceGuid,
                    NULL,
                    &DataSize,
                    &PpData
                    );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  PpData.PPRequest = PpRequest;
  Status           = gRT->SetVariable (
                            PHYSICAL_PRESENCE_VARIABLE,
                            &gEfiPhysicalPresenceGuid,
                            EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
                            DataSize,
                            &PpData
                            );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TcgCallback (
  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
  )
{
  TCG_CONFIG_PRIVATE_DATA  *PrivateData;
  CHAR16                   State[32];
 
  if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {
    if (QuestionId == KEY_TPM_ACTION) {
      PrivateData = TCG_CONFIG_PRIVATE_DATA_FROM_THIS (This);
      UnicodeSPrint (
        State,
        sizeof (State),
        L"%s, and %s",
        PrivateData->Configuration->TpmEnable   ? L"Enabled"   : L"Disabled",
        PrivateData->Configuration->TpmActivate ? L"Activated" : L"Deactivated"
        );
      HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_TPM_STATE_CONTENT), State, NULL);
    }
 
    return EFI_SUCCESS;
  }
 
  if ((Action != EFI_BROWSER_ACTION_CHANGED) || (QuestionId != KEY_TPM_ACTION)) {
    return EFI_UNSUPPORTED;
  }
 
  SavePpRequest (Value->u8);
  *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
InstallTcgConfigForm (
  IN OUT TCG_CONFIG_PRIVATE_DATA  *PrivateData
  )
{
  EFI_STATUS                      Status;
  EFI_HII_HANDLE                  HiiHandle;
  EFI_HANDLE                      DriverHandle;
  EFI_HII_CONFIG_ACCESS_PROTOCOL  *ConfigAccess;
 
  DriverHandle = NULL;
  ConfigAccess = &PrivateData->ConfigAccess;
  Status       = gBS->InstallMultipleProtocolInterfaces (
                        &DriverHandle,
                        &gEfiDevicePathProtocolGuid,
                        &mTcgHiiVendorDevicePath,
                        &gEfiHiiConfigAccessProtocolGuid,
                        ConfigAccess,
                        NULL
                        );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  PrivateData->DriverHandle = DriverHandle;
 
  //
  // Publish the HII package list
  //
  HiiHandle = HiiAddPackages (
                &gTcgConfigFormSetGuid,
                DriverHandle,
                TcgConfigDxeStrings,
                TcgConfigBin,
                NULL
                );
  if (HiiHandle == NULL) {
    gBS->UninstallMultipleProtocolInterfaces (
           DriverHandle,
           &gEfiDevicePathProtocolGuid,
           &mTcgHiiVendorDevicePath,
           &gEfiHiiConfigAccessProtocolGuid,
           ConfigAccess,
           NULL
           );
 
    return EFI_OUT_OF_RESOURCES;
  }
 
  PrivateData->HiiHandle = HiiHandle;
 
  return EFI_SUCCESS;
}
 
VOID
UninstallTcgConfigForm (
  IN OUT TCG_CONFIG_PRIVATE_DATA  *PrivateData
  )
{
  //
  // Uninstall HII package list
  //
  if (PrivateData->HiiHandle != NULL) {
    HiiRemovePackages (PrivateData->HiiHandle);
    PrivateData->HiiHandle = NULL;
  }
 
  //
  // Uninstall HII Config Access Protocol
  //
  if (PrivateData->DriverHandle != NULL) {
    gBS->UninstallMultipleProtocolInterfaces (
           PrivateData->DriverHandle,
           &gEfiDevicePathProtocolGuid,
           &mTcgHiiVendorDevicePath,
           &gEfiHiiConfigAccessProtocolGuid,
           &PrivateData->ConfigAccess,
           NULL
           );
    PrivateData->DriverHandle = NULL;
  }
 
  if (PrivateData->Configuration != NULL) {
    FreePool (PrivateData->Configuration);
  }
 
  FreePool (PrivateData);
}