CapsuleService.c

Go to the documentation of this file.

 
#include "CapsuleService.h"
 
//
// Handle for the installation of Capsule Architecture Protocol.
//
EFI_HANDLE  mNewHandle = NULL;
 
//
// The times of calling UpdateCapsule ()
//
UINTN  mTimes = 0;
 
UINT32  mMaxSizePopulateCapsule    = 0;
UINT32  mMaxSizeNonPopulateCapsule = 0;
 
EFI_STATUS
EFIAPI
UpdateCapsule (
  IN EFI_CAPSULE_HEADER    **CapsuleHeaderArray,
  IN UINTN                 CapsuleCount,
  IN EFI_PHYSICAL_ADDRESS  ScatterGatherList OPTIONAL
  )
{
  UINTN               ArrayNumber;
  EFI_STATUS          Status;
  EFI_CAPSULE_HEADER  *CapsuleHeader;
  BOOLEAN             NeedReset;
  BOOLEAN             InitiateReset;
  CHAR16              CapsuleVarName[30];
  CHAR16              *TempVarName;
 
  //
  // Check if platform support Capsule In RAM or not.
  // Platform could choose to drop CapsulePei/CapsuleX64 and do not support Capsule In RAM.
  //
  if (!PcdGetBool (PcdCapsuleInRamSupport)) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Capsule Count can't be less than one.
  //
  if (CapsuleCount < 1) {
    return EFI_INVALID_PARAMETER;
  }
 
  NeedReset         = FALSE;
  InitiateReset     = FALSE;
  CapsuleHeader     = NULL;
  CapsuleVarName[0] = 0;
 
  for (ArrayNumber = 0; ArrayNumber < CapsuleCount; ArrayNumber++) {
    //
    // A capsule which has the CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag must have
    // CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
    //
    CapsuleHeader = CapsuleHeaderArray[ArrayNumber];
    if ((CapsuleHeader->Flags & (CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE)) == CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // A capsule which has the CAPSULE_FLAGS_INITIATE_RESET flag must have
    // CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
    //
    if ((CapsuleHeader->Flags & (CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_INITIATE_RESET)) == CAPSULE_FLAGS_INITIATE_RESET) {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Check FMP capsule flag
    //
    if (  CompareGuid (&CapsuleHeader->CapsuleGuid, &gEfiFmpCapsuleGuid)
       && ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) != 0))
    {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Check Capsule image without populate flag by firmware support capsule function
    //
    if ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) == 0) {
      Status = SupportCapsuleImage (CapsuleHeader);
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
  }
 
  //
  // Walk through all capsules, record whether there is a capsule needs reset
  // or initiate reset. And then process capsules which has no reset flag directly.
  //
  for (ArrayNumber = 0; ArrayNumber < CapsuleCount; ArrayNumber++) {
    CapsuleHeader = CapsuleHeaderArray[ArrayNumber];
    //
    // Here should be in the boot-time for non-reset capsule image
    // Platform specific update for the non-reset capsule image.
    //
    if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) == 0) {
      if (EfiAtRuntime () && !FeaturePcdGet (PcdSupportProcessCapsuleAtRuntime)) {
        Status = EFI_OUT_OF_RESOURCES;
      } else {
        Status = ProcessCapsuleImage (CapsuleHeader);
      }
 
      if (EFI_ERROR (Status)) {
        return Status;
      }
    } else {
      NeedReset = TRUE;
      if ((CapsuleHeader->Flags & CAPSULE_FLAGS_INITIATE_RESET) != 0) {
        InitiateReset = TRUE;
      }
    }
  }
 
  //
  // After launching all capsules who has no reset flag, if no more capsules claims
  // for a system reset just return.
  //
  if (!NeedReset) {
    return EFI_SUCCESS;
  }
 
  //
  // ScatterGatherList is only referenced if the capsules are defined to persist across
  // system reset.
  //
  if (ScatterGatherList == (EFI_PHYSICAL_ADDRESS)(UINTN)NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Check if the platform supports update capsule across a system reset
  //
  if (!IsPersistAcrossResetCapsuleSupported ()) {
    return EFI_UNSUPPORTED;
  }
 
  CapsuleCacheWriteBack (ScatterGatherList);
 
  //
  // Construct variable name CapsuleUpdateData, CapsuleUpdateData1, CapsuleUpdateData2...
  // if user calls UpdateCapsule multiple times.
  //
  StrCpyS (CapsuleVarName, sizeof (CapsuleVarName)/sizeof (CHAR16), EFI_CAPSULE_VARIABLE_NAME);
  TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
  if (mTimes > 0) {
    UnicodeValueToStringS (
      TempVarName,
      sizeof (CapsuleVarName) - ((UINTN)TempVarName - (UINTN)CapsuleVarName),
      0,
      mTimes,
      0
      );
  }
 
  //
  // ScatterGatherList is only referenced if the capsules are defined to persist across
  // system reset. Set its value into NV storage to let pre-boot driver to pick it up
  // after coming through a system reset.
  //
  Status = EfiSetVariable (
             CapsuleVarName,
             &gEfiCapsuleVendorGuid,
             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
             sizeof (UINTN),
             (VOID *)&ScatterGatherList
             );
  if (!EFI_ERROR (Status)) {
    //
    // Variable has been set successfully, increase variable index.
    //
    mTimes++;
    if (InitiateReset) {
      //
      // Firmware that encounters a capsule which has the CAPSULE_FLAGS_INITIATE_RESET Flag set in its header
      // will initiate a reset of the platform which is compatible with the passed-in capsule request and will
      // not return back to the caller.
      //
      EfiResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
QueryCapsuleCapabilities (
  IN  EFI_CAPSULE_HEADER  **CapsuleHeaderArray,
  IN  UINTN               CapsuleCount,
  OUT UINT64              *MaxiumCapsuleSize,
  OUT EFI_RESET_TYPE      *ResetType
  )
{
  EFI_STATUS          Status;
  UINTN               ArrayNumber;
  EFI_CAPSULE_HEADER  *CapsuleHeader;
  BOOLEAN             NeedReset;
 
  //
  // Capsule Count can't be less than one.
  //
  if (CapsuleCount < 1) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Check whether input parameter is valid
  //
  if ((MaxiumCapsuleSize == NULL) || (ResetType == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  CapsuleHeader = NULL;
  NeedReset     = FALSE;
 
  for (ArrayNumber = 0; ArrayNumber < CapsuleCount; ArrayNumber++) {
    CapsuleHeader = CapsuleHeaderArray[ArrayNumber];
    //
    // A capsule which has the CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE flag must have
    // CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
    //
    if ((CapsuleHeader->Flags & (CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE)) == CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // A capsule which has the CAPSULE_FLAGS_INITIATE_RESET flag must have
    // CAPSULE_FLAGS_PERSIST_ACROSS_RESET set in its header as well.
    //
    if ((CapsuleHeader->Flags & (CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_INITIATE_RESET)) == CAPSULE_FLAGS_INITIATE_RESET) {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Check FMP capsule flag
    //
    if (  CompareGuid (&CapsuleHeader->CapsuleGuid, &gEfiFmpCapsuleGuid)
       && ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) != 0))
    {
      return EFI_INVALID_PARAMETER;
    }
 
    //
    // Check Capsule image without populate flag is supported by firmware
    //
    if ((CapsuleHeader->Flags & CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE) == 0) {
      Status = SupportCapsuleImage (CapsuleHeader);
      if (EFI_ERROR (Status)) {
        return Status;
      }
    }
  }
 
  //
  // Find out whether there is any capsule defined to persist across system reset.
  //
  for (ArrayNumber = 0; ArrayNumber < CapsuleCount; ArrayNumber++) {
    CapsuleHeader = CapsuleHeaderArray[ArrayNumber];
    if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {
      NeedReset = TRUE;
      break;
    }
  }
 
  if (NeedReset) {
    //
    // Check if the platform supports update capsule across a system reset
    //
    if (!IsPersistAcrossResetCapsuleSupported ()) {
      return EFI_UNSUPPORTED;
    }
 
    *ResetType         = EfiResetWarm;
    *MaxiumCapsuleSize = (UINT64)mMaxSizePopulateCapsule;
  } else {
    //
    // For non-reset capsule image.
    //
    *ResetType         = EfiResetCold;
    *MaxiumCapsuleSize = (UINT64)mMaxSizeNonPopulateCapsule;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
CapsuleServiceInitialize (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  mMaxSizePopulateCapsule    = PcdGet32 (PcdMaxSizePopulateCapsule);
  mMaxSizeNonPopulateCapsule = PcdGet32 (PcdMaxSizeNonPopulateCapsule);
 
  //
  // When PEI phase is IA32, DXE phase is X64, it is possible that capsule data are
  // put above 4GB, so capsule PEI will transfer to long mode to get capsule data.
  // The page table and stack is used to transfer processor mode from IA32 to long mode.
  // Create the base address of page table and stack, and save them into variable.
  // This is not needed when capsule with reset type is not supported.
  //
  SaveLongModeContext ();
 
  //
  // Install capsule runtime services into UEFI runtime service tables.
  //
  gRT->UpdateCapsule            = UpdateCapsule;
  gRT->QueryCapsuleCapabilities = QueryCapsuleCapabilities;
 
  //
  // Install the Capsule Architectural Protocol on a new handle
  // to signify the capsule runtime services are ready.
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &mNewHandle,
                  &gEfiCapsuleArchProtocolGuid,
                  NULL,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}