Tcg2Smm.c

Go to the documentation of this file.

 
#include "Tcg2Smm.h"
 
EFI_SMM_VARIABLE_PROTOCOL  *mSmmVariable = NULL;
TCG_NVS                    *mTcgNvs      = NULL;
UINTN                      mPpSoftwareSmi;
UINTN                      mMcSoftwareSmi;
EFI_HANDLE                 mReadyToLockHandle;
 
EFI_STATUS
EFIAPI
TpmNvsCommunciate (
  IN     EFI_HANDLE  DispatchHandle,
  IN     CONST VOID  *RegisterContext,
  IN OUT VOID        *CommBuffer,
  IN OUT UINTN       *CommBufferSize
  )
{
  EFI_STATUS              Status;
  UINTN                   TempCommBufferSize;
  TPM_NVS_MM_COMM_BUFFER  *CommParams;
 
  DEBUG ((DEBUG_VERBOSE, "%a()\n", __func__));
 
  //
  // If input is invalid, stop processing this SMI
  //
  if ((CommBuffer == NULL) || (CommBufferSize == NULL)) {
    return EFI_SUCCESS;
  }
 
  TempCommBufferSize = *CommBufferSize;
 
  if (TempCommBufferSize != sizeof (TPM_NVS_MM_COMM_BUFFER)) {
    DEBUG ((DEBUG_ERROR, "[%a] MM Communication buffer size is invalid for this handler!\n", __func__));
    return EFI_ACCESS_DENIED;
  }
 
  CommParams = (TPM_NVS_MM_COMM_BUFFER *)CommBuffer;
 
  //
  // The Primary Buffer validation
  //
  if (!Tcg2IsPrimaryBufferValid ((UINTN)CommBuffer, TempCommBufferSize)) {
    DEBUG ((DEBUG_ERROR, "[%a] - MM Communication buffer in invalid location!\n", __func__));
    return EFI_ACCESS_DENIED;
  }
 
  //
  // The NonPrimary Buffer validation
  //
  if (!Tcg2IsNonPrimaryBufferValid (CommParams->TargetAddress, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (sizeof (TCG_NVS))))) {
    DEBUG ((DEBUG_ERROR, "[%a] - MM NonPrimary buffer pointed from Communication buffer in invalid location!\n", __func__));
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Farm out the job to individual functions based on what was requested.
  //
  Status = EFI_SUCCESS;
  switch (CommParams->Function) {
    case TpmNvsMmExchangeInfo:
      DEBUG ((DEBUG_VERBOSE, "[%a] - Function requested: MM_EXCHANGE_NVS_INFO\n", __func__));
      CommParams->RegisteredPpSwiValue = mPpSoftwareSmi;
      CommParams->RegisteredMcSwiValue = mMcSoftwareSmi;
      mTcgNvs                          = (TCG_NVS *)(UINTN)CommParams->TargetAddress;
      break;
 
    default:
      DEBUG ((DEBUG_INFO, "[%a] - Unknown function %d!\n", __func__, CommParams->Function));
      Status = EFI_UNSUPPORTED;
      break;
  }
 
  CommParams->ReturnStatus = (UINT64)Status;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PhysicalPresenceCallback (
  IN EFI_HANDLE  DispatchHandle,
  IN CONST VOID  *Context,
  IN OUT VOID    *CommBuffer,
  IN OUT UINTN   *CommBufferSize
  )
{
  UINT32  MostRecentRequest;
  UINT32  Response;
  UINT32  OperationRequest;
  UINT32  RequestParameter;
 
  if (mTcgNvs->PhysicalPresence.Parameter == TCG_ACPI_FUNCTION_RETURN_REQUEST_RESPONSE_TO_OS) {
    mTcgNvs->PhysicalPresence.ReturnCode = Tcg2PhysicalPresenceLibReturnOperationResponseToOsFunction (
                                             &MostRecentRequest,
                                             &Response
                                             );
    mTcgNvs->PhysicalPresence.LastRequest = MostRecentRequest;
    mTcgNvs->PhysicalPresence.Response    = Response;
    return EFI_SUCCESS;
  } else if (  (mTcgNvs->PhysicalPresence.Parameter == TCG_ACPI_FUNCTION_SUBMIT_REQUEST_TO_BIOS)
            || (mTcgNvs->PhysicalPresence.Parameter == TCG_ACPI_FUNCTION_SUBMIT_REQUEST_TO_BIOS_2))
  {
    OperationRequest                     = mTcgNvs->PhysicalPresence.Request;
    RequestParameter                     = mTcgNvs->PhysicalPresence.RequestParameter;
    mTcgNvs->PhysicalPresence.ReturnCode = Tcg2PhysicalPresenceLibSubmitRequestToPreOSFunctionEx (
                                             &OperationRequest,
                                             &RequestParameter
                                             );
    mTcgNvs->PhysicalPresence.Request          = OperationRequest;
    mTcgNvs->PhysicalPresence.RequestParameter = RequestParameter;
  } else if (mTcgNvs->PhysicalPresence.Parameter == TCG_ACPI_FUNCTION_GET_USER_CONFIRMATION_STATUS_FOR_REQUEST) {
    mTcgNvs->PhysicalPresence.ReturnCode = Tcg2PhysicalPresenceLibGetUserConfirmationStatusFunction (mTcgNvs->PPRequestUserConfirm);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TcgMmReadyToLock (
  IN CONST EFI_GUID  *Protocol,
  IN VOID            *Interface,
  IN EFI_HANDLE      Handle
  )
{
  EFI_STATUS  Status;
 
  Status = EFI_SUCCESS;
 
  if (mReadyToLockHandle != NULL) {
    Status             = gMmst->MmiHandlerUnRegister (mReadyToLockHandle);
    mReadyToLockHandle = NULL;
  }
 
  return Status;
}
 
EFI_STATUS
InitializeTcgCommon (
  VOID
  )
{
  EFI_STATUS                     Status;
  EFI_SMM_SW_DISPATCH2_PROTOCOL  *SwDispatch;
  EFI_SMM_SW_REGISTER_CONTEXT    SwContext;
  EFI_HANDLE                     PpSwHandle;
  EFI_HANDLE                     McSwHandle;
  EFI_HANDLE                     NotifyHandle;
 
  if (!IsTpm20Dtpm ()) {
    DEBUG ((DEBUG_ERROR, "No TPM2 DTPM instance required!\n"));
    return EFI_UNSUPPORTED;
  }
 
  // Initialize variables first
  mReadyToLockHandle = NULL;
  SwDispatch         = NULL;
  PpSwHandle         = NULL;
  McSwHandle         = NULL;
  NotifyHandle       = NULL;
 
  // Register a root handler to communicate the NVS region and SMI channel between MM and DXE
  Status = gMmst->MmiHandlerRegister (TpmNvsCommunciate, &gTpmNvsMmGuid, &mReadyToLockHandle);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "[%a] Failed to register NVS communicate as root MM handler - %r!\n", __func__, Status));
    goto Cleanup;
  }
 
  //
  // Get the Sw dispatch protocol and register SMI callback functions.
  //
  Status = gMmst->MmLocateProtocol (&gEfiSmmSwDispatch2ProtocolGuid, NULL, (VOID **)&SwDispatch);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "[%a] Failed to locate Sw dispatch protocol - %r!\n", __func__, Status));
    goto Cleanup;
  }
 
  SwContext.SwSmiInputValue = (UINTN)-1;
  Status                    = SwDispatch->Register (SwDispatch, PhysicalPresenceCallback, &SwContext, &PpSwHandle);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "[%a] Failed to register PP callback as SW MM handler - %r!\n", __func__, Status));
    goto Cleanup;
  }
 
  mPpSoftwareSmi = SwContext.SwSmiInputValue;
 
  //
  // Locate SmmVariableProtocol.
  //
  Status = gMmst->MmLocateProtocol (&gEfiSmmVariableProtocolGuid, NULL, (VOID **)&mSmmVariable);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    // Should not happen
    DEBUG ((DEBUG_ERROR, "[%a] Failed to locate SMM variable protocol - %r!\n", __func__, Status));
    goto Cleanup;
  }
 
  // Turn off the light before leaving the room... at least, take a remote...
  Status = gMmst->MmRegisterProtocolNotify (&gEfiMmReadyToLockProtocolGuid, TcgMmReadyToLock, &NotifyHandle);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "[%a] Failed to register ready to lock notification - %r!\n", __func__, Status));
    goto Cleanup;
  }
 
  Tcg2NotifyMmReady ();
 
Cleanup:
  if (EFI_ERROR (Status)) {
    // Something is whacked, clean up the mess...
    if (NotifyHandle != NULL) {
      gMmst->MmRegisterProtocolNotify (&gEfiMmReadyToLockProtocolGuid, NULL, &NotifyHandle);
    }
 
    if ((McSwHandle != NULL) && (SwDispatch != NULL)) {
      SwDispatch->UnRegister (SwDispatch, McSwHandle);
    }
 
    if ((PpSwHandle != NULL) && (SwDispatch != NULL)) {
      SwDispatch->UnRegister (SwDispatch, PpSwHandle);
    }
 
    if (mReadyToLockHandle != NULL) {
      gMmst->MmiHandlerUnRegister (mReadyToLockHandle);
    }
  }
 
  return Status;
}