MicrocodeLib.c

Go to the documentation of this file.

 
#include <Uefi/UefiBaseType.h>
#include <Register/Intel/Cpuid.h>
#include <Register/Intel/ArchitecturalMsr.h>
#include <Register/Intel/Microcode.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Ppi/ShadowMicrocode.h>
 
UINT32
EFIAPI
GetProcessorMicrocodeSignature (
  VOID
  )
{
  MSR_IA32_BIOS_SIGN_ID_REGISTER  BiosSignIdMsr;
 
  AsmWriteMsr64 (MSR_IA32_BIOS_SIGN_ID, 0);
  AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, NULL, NULL);
  BiosSignIdMsr.Uint64 = AsmReadMsr64 (MSR_IA32_BIOS_SIGN_ID);
  return BiosSignIdMsr.Bits.MicrocodeUpdateSignature;
}
 
VOID
EFIAPI
GetProcessorMicrocodeCpuId (
  EDKII_PEI_MICROCODE_CPU_ID  *MicrocodeCpuId
  )
{
  MSR_IA32_PLATFORM_ID_REGISTER  PlatformIdMsr;
 
  ASSERT (MicrocodeCpuId != NULL);
 
  PlatformIdMsr.Uint64       = AsmReadMsr64 (MSR_IA32_PLATFORM_ID);
  MicrocodeCpuId->PlatformId = (UINT8)PlatformIdMsr.Bits.PlatformId;
  AsmCpuid (CPUID_VERSION_INFO, &MicrocodeCpuId->ProcessorSignature, NULL, NULL, NULL);
}
 
UINT32
EFIAPI
GetMicrocodeLength (
  IN CPU_MICROCODE_HEADER  *Microcode
  )
{
  UINT32  TotalSize;
 
  ASSERT (Microcode != NULL);
 
  TotalSize = 2048;
  if (Microcode->DataSize != 0) {
    TotalSize = Microcode->TotalSize;
  }
 
  return TotalSize;
}
 
VOID
EFIAPI
LoadMicrocode (
  IN CPU_MICROCODE_HEADER  *Microcode
  )
{
  ASSERT (Microcode != NULL);
 
  AsmWriteMsr64 (MSR_IA32_BIOS_UPDT_TRIG, (UINT64)(UINTN)(Microcode + 1));
}
 
BOOLEAN
IsProcessorMatchedMicrocode (
  IN UINT32                      ProcessorSignature,
  IN UINT32                      ProcessorFlags,
  IN EDKII_PEI_MICROCODE_CPU_ID  *MicrocodeCpuId,
  IN UINTN                       MicrocodeCpuIdCount
  )
{
  UINTN  Index;
 
  if (MicrocodeCpuIdCount == 0) {
    return TRUE;
  }
 
  for (Index = 0; Index < MicrocodeCpuIdCount; Index++) {
    if ((ProcessorSignature == MicrocodeCpuId[Index].ProcessorSignature) &&
        ((ProcessorFlags & (1 << MicrocodeCpuId[Index].PlatformId)) != 0))
    {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
BOOLEAN
EFIAPI
IsValidMicrocode (
  IN CPU_MICROCODE_HEADER        *Microcode,
  IN UINTN                       MicrocodeLength,
  IN UINT32                      MinimumRevision,
  IN EDKII_PEI_MICROCODE_CPU_ID  *MicrocodeCpuIds,
  IN UINTN                       MicrocodeCpuIdCount,
  IN BOOLEAN                     VerifyChecksum
  )
{
  UINTN                                Index;
  UINT32                               DataSize;
  UINT32                               TotalSize;
  CPU_MICROCODE_EXTENDED_TABLE         *ExtendedTable;
  CPU_MICROCODE_EXTENDED_TABLE_HEADER  *ExtendedTableHeader;
  UINT32                               ExtendedTableLength;
  UINT32                               Sum32;
  BOOLEAN                              Match;
 
  ASSERT (Microcode != NULL);
 
  //
  // It's invalid when:
  //   the input microcode buffer is so small that even cannot contain the header.
  //   the input microcode buffer is so large that exceeds MAX_ADDRESS.
  //
  if ((MicrocodeLength < sizeof (CPU_MICROCODE_HEADER)) || (MicrocodeLength > (MAX_ADDRESS - (UINTN)Microcode))) {
    return FALSE;
  }
 
  //
  // Per SDM, HeaderVersion and LoaderRevision should both be 1.
  //
  if ((Microcode->HeaderVersion != 1) || (Microcode->LoaderRevision != 1)) {
    return FALSE;
  }
 
  //
  // The microcode revision should be larger than the minimum revision.
  //
  if (Microcode->UpdateRevision <= MinimumRevision) {
    return FALSE;
  }
 
  DataSize = Microcode->DataSize;
  if (DataSize == 0) {
    DataSize = 2000;
  }
 
  //
  // Per SDM, DataSize should be multiple of DWORDs.
  //
  if ((DataSize % 4) != 0) {
    return FALSE;
  }
 
  TotalSize = GetMicrocodeLength (Microcode);
 
  //
  // Check whether the whole microcode is within the buffer.
  // TotalSize should be multiple of 1024.
  //
  if (((TotalSize % SIZE_1KB) != 0) || (TotalSize > MicrocodeLength)) {
    return FALSE;
  }
 
  //
  // The summation of all DWORDs in microcode should be zero.
  //
  if (VerifyChecksum && (CalculateSum32 ((UINT32 *)Microcode, TotalSize) != 0)) {
    return FALSE;
  }
 
  Sum32 = Microcode->ProcessorSignature.Uint32 + Microcode->ProcessorFlags + Microcode->Checksum;
 
  //
  // Check the processor signature and platform ID in the primary header.
  //
  Match = IsProcessorMatchedMicrocode (
            Microcode->ProcessorSignature.Uint32,
            Microcode->ProcessorFlags,
            MicrocodeCpuIds,
            MicrocodeCpuIdCount
            );
  if (Match) {
    return TRUE;
  }
 
  ExtendedTableLength = TotalSize - (DataSize + sizeof (CPU_MICROCODE_HEADER));
  if ((ExtendedTableLength < sizeof (CPU_MICROCODE_EXTENDED_TABLE_HEADER)) || ((ExtendedTableLength % 4) != 0)) {
    return FALSE;
  }
 
  //
  // Extended Table exist, check if the CPU in support list
  //
  ExtendedTableHeader = (CPU_MICROCODE_EXTENDED_TABLE_HEADER *)((UINTN)(Microcode + 1) + DataSize);
  if (ExtendedTableHeader->ExtendedSignatureCount > MAX_UINT32 / sizeof (CPU_MICROCODE_EXTENDED_TABLE)) {
    return FALSE;
  }
 
  if (ExtendedTableHeader->ExtendedSignatureCount * sizeof (CPU_MICROCODE_EXTENDED_TABLE)
      > ExtendedTableLength - sizeof (CPU_MICROCODE_EXTENDED_TABLE_HEADER))
  {
    return FALSE;
  }
 
  //
  // Check the extended table checksum
  //
  if (VerifyChecksum && (CalculateSum32 ((UINT32 *)ExtendedTableHeader, ExtendedTableLength) != 0)) {
    return FALSE;
  }
 
  ExtendedTable = (CPU_MICROCODE_EXTENDED_TABLE *)(ExtendedTableHeader + 1);
  for (Index = 0; Index < ExtendedTableHeader->ExtendedSignatureCount; Index++) {
    if (VerifyChecksum &&
        (ExtendedTable[Index].ProcessorSignature.Uint32 + ExtendedTable[Index].ProcessorFlag
         + ExtendedTable[Index].Checksum != Sum32))
    {
      //
      // The extended table entry is valid when the summation of Processor Signature, Processor Flags
      // and Checksum equal to the coresponding summation from primary header. Because:
      //    CalculateSum32 (Header + Update Binary) == 0
      //    CalculateSum32 (Header + Update Binary)
      //        - (Header.ProcessorSignature + Header.ProcessorFlag + Header.Checksum)
      //        + (Extended.ProcessorSignature + Extended.ProcessorFlag + Extended.Checksum) == 0
      // So,
      //    (Header.ProcessorSignature + Header.ProcessorFlag + Header.Checksum)
      //     == (Extended.ProcessorSignature + Extended.ProcessorFlag + Extended.Checksum)
      //
      continue;
    }
 
    Match = IsProcessorMatchedMicrocode (
              ExtendedTable[Index].ProcessorSignature.Uint32,
              ExtendedTable[Index].ProcessorFlag,
              MicrocodeCpuIds,
              MicrocodeCpuIdCount
              );
    if (Match) {
      return TRUE;
    }
  }
 
  return FALSE;
}