xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakeChipsetPkg/CapsuleIFWU/CapsuleUcodeDxe/MicrocodeUpdate.c

3707 lines
133 KiB
C
Raw Blame History

/** @file
Firmware Management Protocol implementation for Capsule Processor
;******************************************************************************
;* Copyright (c) 2020 - 2021, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
/** @file
SetImage instance to update Microcode.
Caution: This module requires additional review when modified.
This module will have external input - uCode capsule image.
This external input must be validated carefully to avoid security issue like
buffer overflow, integer overflow.
MicrocodeWrite() and VerifyMicrocode() will receive untrusted input and do basic validation.
Copyright (c) 2016 - 2020, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "MicrocodeUpdate.h"
///
/// Last Attempt Status Values
///
#define LAST_ATTEMPT_STATUS_SUCCESS 0x00000000
#define LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL 0x00000001
#define LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES 0x00000002
#define LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION 0x00000003
#define LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT 0x00000004
#define LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR 0x00000005
#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_AC 0x00000006
#define LAST_ATTEMPT_STATUS_ERROR_PWR_EVT_BATT 0x00000007
#define LAST_ATTEMPT_STATUS_ERROR_UNSATISFIED_DEPENDENCIES 0x00000008
STATIC UINT8 InsydeBiosGuardSig[] = {'$', 'P', 'F', 'A', 'T', 'H', 'D', 'R'};
STATIC UINT8 InsydeCertSig[] = {'$', 'P', 'F', 'A', 'T', 'C', 'E', 'R'};
STATIC UINT8 InsydeUcodeSig[] = {'$', '_', 'M', 'I', 'C', 'R', 'O', 'C', 'O', 'D', 'E', '_', 'I', 'M', 'G', '_'};
STATIC UINT8 InsydeCertHeaderSig[] = {'$', '_', 'P', 'F', 'A', 'T', '_', 'C', 'E', 'R', '_', 'I', 'M', 'G', '_'};
STATIC UINT8 InsydeBgupHeaderSig[] = {'$', '_', 'P', 'F', 'A', 'T', '_', 'H', 'D', 'R', '_', 'I', 'M', 'G', '_'};
typedef struct _INSYDE_BIOSGUARD_HEADER {
UINT8 Signature[8]; // $PFATHDR
UINT32 Version; // 0x00000002
UINT32 BlockCount; // Block Count (Total count of PUP blocks)
UINT32 BlockSize; // Block Size (Size of each PUP block)
UINT32 StructureSize; // INSYDE_BIOSGUARD_HEADER Structure Size
//UINT32 DataSizeList[BlockCount]; // Data size of each PUP block (<=64K)
} INSYDE_BIOSGUARD_HEADER;
typedef struct _INSYDE_CERT_HEADER {
UINT8 Signature[8]; // $PFATCER
UINT32 Version; // 0x00000001
UINT32 BlockCount; // Block Count (Total count of PUP blocks)
UINT32 BlockSize; // Block Size (Size of each PUP block)
UINT32 Checksum;
UINT8 Reserved[8];
} INSYDE_CERT_HEADER;
typedef struct {
VOID *InputData;
UINTN InputSize;
VOID *Bgup;
UINTN BgupSize;
VOID *Cert;
UINTN CertSize;
} BIOS_GUARD_DATA;
EFI_STATUS
TopSwapControl (
IN BOOLEAN Enable
)
{
//f (mBiosGuardEnabled) {
// //
// // TopSwap will be manipulated in BGUP script
// //
// return EFI_SUCCESS;
//}
ASSERT (PcdGet8 (PcdTopSwapEnableSwSmi) != 0xFF);
ASSERT (PcdGet8 (PcdTopSwapDisableSwSmi) != 0xFF);
if (Enable) {
DEBUG ((DEBUG_INFO, "Enable TopSwap via SwSmi (0x%x)\n", PcdGet8 (PcdTopSwapEnableSwSmi)));
IoWrite8 (R_PCH_IO_APM_CNT, PcdGet8 (PcdTopSwapEnableSwSmi));
} else {
DEBUG ((DEBUG_INFO, "Disable TopSwap via SwSmi (0x%x)\n", PcdGet8 (PcdTopSwapDisableSwSmi)));
IoWrite8 (R_PCH_IO_APM_CNT, PcdGet8 (PcdTopSwapDisableSwSmi));
}
return EFI_SUCCESS;
}
EFI_STATUS
GetUcodeCapsuleInfo (
IN CONST VOID *Capsule,
IN OUT H2O_CAPSULE_HEADER **H2oCapsuleHeader
) {
EFI_STATUS Status;
EFI_CAPSULE_HEADER *Datatbuffer;
UINT8 *Ptr;
UINTN Index;
Datatbuffer = ((EFI_CAPSULE_HEADER*)Capsule);
if (CompareGuid(&Datatbuffer->CapsuleGuid, PcdGetPtr (PcdWindowsUcodeFirmwareCapsuleGuid))) {
for (Index = 0; Index < Datatbuffer->CapsuleImageSize; Index++) {
Ptr = (UINT8 *)Datatbuffer + Datatbuffer->HeaderSize + Index;
if (CompareMem (Ptr, InsydeUcodeSig, sizeof (InsydeUcodeSig)) == 0) {
*H2oCapsuleHeader = (H2O_CAPSULE_HEADER *) Ptr;
break;
}
}
}
Status = EFI_NOT_FOUND;
if ((*H2oCapsuleHeader)->RealSize != 0) {
return EFI_SUCCESS;
}
return Status;
}
EFI_STATUS
SetUpdateProgress (
IN SYSTEM_FIRMWARE_COMPONENT UpdatingComponent,
IN UINT32 UpdatingProgress
)
{
EFI_STATUS Status;
SYSTEM_FIRMWARE_UPDATE_PROGRESS UpdateProgress;
UpdateProgress.Component = UpdatingComponent;
UpdateProgress.Progress = UpdatingProgress;
Status = gRT->SetVariable (
SYSFW_UPDATE_PROGRESS_VARIABLE_NAME,
&gSysFwUpdateProgressGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (SYSTEM_FIRMWARE_UPDATE_PROGRESS),
&UpdateProgress
);
return Status;
}
VOID
ClearUpdateProgress (
VOID
)
{
gRT->SetVariable (
L"FmpCapsuleInfo",
&gFmpCapsuleInfoGuid,
0,
0,
NULL
);
gRT->SetVariable (
SYSFW_UPDATE_PROGRESS_VARIABLE_NAME,
&gSysFwUpdateProgressGuid,
0,
0,
NULL
);
}
/**
Update a block on flash.
@param[in] Src Number of blocks to be erased
@param[in] NumBytes Contains the total size of the buffer.
@param[in] WriteAddress Target address to be updated
@retval EFI_SUCCESS. Operation is successful.
@retval EFI_INVALID_PARAMETER Src is NULL or WriteAddress is not well aligned.
@retval EFI_OUT_OF_RESOURCES Failed to allocate needed memory buffer.
@retval EFI_VOLUME_CORRUPTED The block is not updated as expected.
@retval Others If there is any device errors.
**/
STATIC
EFI_STATUS
FlashUpdate (
IN UINT8 *Src,
IN UINTN NumBytes,
IN UINTN WriteAddress
)
{
EFI_STATUS Status;
UINT8 *CompareBuffer;
UINTN Size;
if ((Src == NULL) || ((NumBytes % GetFlashBlockSize ()) != 0) || ((WriteAddress % SIZE_4KB) != 0)) {
return EFI_INVALID_PARAMETER;
}
CompareBuffer = AllocateZeroPool (NumBytes);
if (CompareBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto Exit;
}
Status = FlashRead (
CompareBuffer,
(UINT8 *)WriteAddress,
NumBytes
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Read flash address 0x%x error %r\n", WriteAddress));
goto Exit;
}
if (CompareMem (CompareBuffer, Src, NumBytes) == 0) {
//
// No need to update
//
Status = EFI_SUCCESS;
goto Exit;
}
Status = FlashErase (WriteAddress, NumBytes);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Erase flash address 0x%x error %r\n", WriteAddress));
goto Exit;
}
Size = NumBytes;
Status = FlashProgram (
(UINT8 *)WriteAddress,
(UINT8 *)Src,
&Size,
WriteAddress
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Program flash address 0x%x error %r\n", WriteAddress));
goto Exit;
}
//
// Read buffer back to verify udpate status
//
ZeroMem (CompareBuffer, NumBytes);
Status = FlashRead (
CompareBuffer,
(UINT8 *)WriteAddress,
NumBytes
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "Read flash address 0x%x error %r\n", WriteAddress));
goto Exit;
}
if (CompareMem (CompareBuffer, Src, NumBytes) != 0) {
//
// Block is not updated as expected.
//
Status = EFI_VOLUME_CORRUPTED;
DEBUG ((DEBUG_ERROR, "FlashUpdate: Block is not updated as expected.\n"));
}
Exit:
if (CompareBuffer != NULL) {
FreePool (CompareBuffer);
}
return Status;
}
EFI_STATUS
EFIAPI
MicrocodeFlashWrite(
IN EFI_PHYSICAL_ADDRESS FlashAddress,
IN VOID *Buffer,
IN UINTN Length
)
{
EFI_PHYSICAL_ADDRESS AlignedFlashAddress;
VOID *AlignedBuffer;
UINTN AlignedLength;
UINTN OffsetHead;
UINTN OffsetTail;
EFI_STATUS Status;
DEBUG((EFI_D_INFO, "MicrocodeFlashWrite - 0x%x - 0x%x\n", (UINTN)FlashAddress, Length));
//
// Need make buffer 64K aligned to support ERASE
//
// [Aligned] FlashAddress Aligned]
// | | |
// V V V
// +--------------+========+------------+
// | OffsetHeader | Length | OffsetTail |
// +--------------+========+------------+
// ^
// |<-----------AlignedLength----------->
// |
// AlignedFlashAddress
//
OffsetHead = FlashAddress & (SIZE_4KB - 1);
OffsetTail = (FlashAddress + Length) & (SIZE_4KB - 1);
if (OffsetTail != 0) {
OffsetTail = SIZE_4KB - OffsetTail;
}
if ((OffsetHead != 0) || (OffsetTail != 0)) {
AlignedFlashAddress = FlashAddress - OffsetHead;
AlignedLength = Length + OffsetHead + OffsetTail;
AlignedBuffer = AllocatePool(AlignedLength);
if (AlignedBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Save original buffer. We can't use MMIO read because TopSwap bit may be toggled
// We must use SPI Read
//
//
// 1. Copy content in Header alignment area
//
if (OffsetHead != 0) {
Status = FlashRead (
(UINT8 *)AlignedBuffer,
(UINT8 *)AlignedFlashAddress,
OffsetHead
);
ASSERT(!EFI_ERROR(Status));
}
//
// 2. Copy content in Tail alignment area
//
if (OffsetTail != 0) {
Status = FlashRead (
(UINT8 *)AlignedBuffer + OffsetHead + Length,
(UINT8 *)(AlignedFlashAddress + OffsetHead + Length),
OffsetTail
);
ASSERT(!EFI_ERROR(Status));
}
//
// Override new buffer. Source is from memory. No need to use SPI
//
CopyMem((UINT8 *)AlignedBuffer + OffsetHead, Buffer, Length);
} else {
AlignedFlashAddress = FlashAddress;
AlignedBuffer = Buffer;
AlignedLength = Length;
}
Status = FlashUpdate (
(UINT8 *)AlignedBuffer,
AlignedLength,
(UINTN)AlignedFlashAddress
);
if ((OffsetHead != 0) || (OffsetTail != 0)) {
FreePool (AlignedBuffer);
}
return Status;
}
/*
For fault tolerant test usage. Will clean it after moving to CR Common
*/
EFI_STATUS
TestDeadLoop(
VOID
)
{
EFI_STATUS Status;
BOOLEAN IsFirstDeadLoop;
UINTN DataSize;
Status = EFI_NOT_FOUND;
DataSize = sizeof(BOOLEAN);
Status = gRT->GetVariable(
L"IsFirstDeadLoop",
&gEfiCallerIdGuid,
NULL,
&DataSize,
&IsFirstDeadLoop
);
if (Status != EFI_NOT_FOUND) {
DEBUG ((DEBUG_INFO, "Recovery from crash! Skip deadloop.\n"));
return Status;
}
IsFirstDeadLoop = TRUE;
Status = gRT->SetVariable(
L"IsFirstDeadLoop",
&gEfiCallerIdGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
sizeof(BOOLEAN),
&IsFirstDeadLoop
);
DEBUG ((DEBUG_INFO, "Recovery from crash! deadloop.\n"));
//
// Either stop and manual remove power to cause crash or auto reset system can be used
//
CpuDeadLoop();
//gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
return EFI_SUCCESS;
}
/**
Check if input CPU index is in new uCode targeted CPU list.
@param[in] CpuIndex Given CPU Index to check
@param[in] TargetProcessorBuf Target CPU processor buffer
@param[in] TargetProcessorNum number Target CPU processor in buffer
@retval TRUE Given CpuIndex is in target uCode CPU list
@retval FALSE Given CpuIndex is not in target uCode CPU list.
**/
BOOLEAN
IsCpuInTargetCpuList(
UINTN CpuIndex,
UINTN *TargetProcessorBuf,
UINTN TargetProcessorNum
)
{
UINTN Index;
for (Index = 0; Index < TargetProcessorNum; Index++ ) {
if (CpuIndex == TargetProcessorBuf[Index]) {
return TRUE;
}
}
return FALSE;
}
/**
Get Microcode Region.
@param[out] MicrocodePatchAddress The address of Microcode
@param[out] MicrocodePatchRegionSize The region size of Microcode
@retval TRUE The Microcode region is returned.
@retval FALSE No Microcode region.
**/
BOOLEAN
GetMicrocodeRegion (
OUT VOID **MicrocodePatchAddress,
OUT UINTN *MicrocodePatchRegionSize
)
{
//
// Flash Block size alignment is not required for TopSwap Recovery storage selection
// It is a requirement only when we use Mechanism 2 Option 1.
//
ASSERT((PcdGet32(PcdFlashNvStorageMicrocodeBase) % SIZE_4KB) == 0 && (PcdGet32(PcdFlashNvStorageMicrocodeSize) % SIZE_4KB) == 0);
//
// Exclude FV header and FFS header
// We must ensure CpuMicrocodePatchAddress & PcdCpuMicrocodePatchRegionSize must be Flash block size aligned
//
// ToDo:
// 4KB is hardcode rightnow. We can use PcdFlashMicrocodeOffset in the future
//
*MicrocodePatchAddress = (VOID *)((UINTN)(FixedPcdGet32 (PcdFlashNvStorageMicrocodeBase) + SIZE_4KB));
*MicrocodePatchRegionSize = (UINTN)(FixedPcdGet32 (PcdFlashNvStorageMicrocodeSize) - SIZE_4KB) ;
DEBUG ((DEBUG_INFO, "MicrocodePatchAddress 0x%x\n", *MicrocodePatchAddress));
DEBUG ((DEBUG_INFO, "MicrocodePatchRegionSize 0x%x\n", *MicrocodePatchRegionSize));
if ((*MicrocodePatchAddress == NULL) || (*MicrocodePatchRegionSize == 0)) {
return FALSE;
}
return TRUE;
}
/**
Calculates the checksum of the header of a file.
@param FileHeader Pointer to FFS File Header.
@return Checksum of the header.
Zero means the header is good.
Non-zero means the header is bad.
**/
UINT8
GetHeaderChecksum (
IN EFI_FFS_FILE_HEADER *FileHeader
)
{
EFI_FFS_FILE_HEADER2 TestFileHeader;
if (IS_FFS_FILE2 (FileHeader)) {
CopyMem (&TestFileHeader, FileHeader, sizeof (EFI_FFS_FILE_HEADER2));
//
// Ingore State and File field in FFS header.
// Set Header field to 0
//
TestFileHeader.State = 0;
TestFileHeader.IntegrityCheck.Checksum16 = 0;
return (0 - CalculateSum8 ((CONST UINT8 *) &TestFileHeader, sizeof (EFI_FFS_FILE_HEADER2)));
} else {
CopyMem (&TestFileHeader, FileHeader, sizeof (EFI_FFS_FILE_HEADER));
//
// Ingore State and File field in FFS header.
// Set Header filed to 0
//
TestFileHeader.State = 0;
TestFileHeader.IntegrityCheck.Checksum16 = 0;
return (0 - CalculateSum8 ((CONST UINT8 *) &TestFileHeader, sizeof (EFI_FFS_FILE_HEADER)));
}
}
/**
Exract uCode Payload, It follows RFC 4506 External Data Representation Standard (XDR)
each element is a variable-length opaque data. Elements are organized in Fixed-Length Array.
Now Array contains 4 entries below. Some elements are optional regarding platform configuration.
uCode capsule generater need to mark length n = 0 in variable-length opaque data element .
--------------------------------------
| UCodeFullRangeImage |
--------------------------------------
| UCodeFullRangeBgup (Optional) |
----------------------------
| uCode Version(Optional) |
--------------------------------------
| uCdeArray(Optional) |
--------------------------------------
@param[In] Image uCode Capsule payload
@param[In] ImageSize uCode Capsule payload length
@param[Out] EntryList List of parsed XDR entry
@param[Out] EntryCount Entry count in the list
@retval Status status of parsing uCode Capsule XDR formated data.
**/
EFI_STATUS
ExtractuCodeCapsuleXdrData (
IN VOID *Image,
IN UINTN ImageSize,
OUT UCODE_PAYLOAD_ENTRY **EntryList,
OUT UINTN *ListCount
)
{
EFI_STATUS Status;
UINTN Index;
UINT8 *PayloadXdr;
UINT8 *PayloadXdrEnd;
UCODE_PAYLOAD_ENTRY *XdrEntryArray;
UINTN XdrEntryLength;
ASSERT(((UINTN)Image % sizeof(UINT32)) == 0);
PayloadXdr = (UINT8 *)Image;
PayloadXdrEnd = (UINT8 *)Image + ImageSize;
Index = 0;
*EntryList = NULL;
*ListCount = 0;
XdrEntryArray = AllocateZeroPool(uCodeArrayMax * sizeof(UCODE_PAYLOAD_ENTRY));
if (XdrEntryArray == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Iterate each data entry within uCode capsule payload
//
while (PayloadXdr < PayloadXdrEnd) {
if ((PayloadXdr + sizeof (UINT32)) > PayloadXdrEnd) {
//
// Xdr described data and Xdr itself should not exceed payload boundary
//
DEBUG ((DEBUG_ERROR, "ExtractuCodeCapsuleXdrData: Xdr described data exceeds boundary.\n"));
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
//
// Read key length stored in big-endian format
//
XdrEntryLength = SwapBytes32 (*(UINT32 *)(PayloadXdr));
//
// Point to the start of the uCode payload data entry
//
PayloadXdr += sizeof (UINT32);
if (PayloadXdr + XdrEntryLength > PayloadXdrEnd) {
//
// Xdr described data and Xdr itself should not exceed payload boundary
//
DEBUG ((DEBUG_ERROR, "ExtractuCodeCapsuleXdrData: Xdr described data exceeds boundary.\n"));
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
//
// Check if there is free room to save payload entry
//
if (Index >= uCodeArrayMax) {
DEBUG ((DEBUG_ERROR, "ExtractuCodeCapsuleXdrData: Xdr described data exceeds maximum entry number %x.\n", uCodeArrayMax));
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
XdrEntryArray[Index].EntryPtr = PayloadXdr;
XdrEntryArray[Index].EntrySize = XdrEntryLength;
Index++;
PayloadXdr += XdrEntryLength;
//
// According to RFC 4506, Chapter 3, each XDR descriptor must be aligned to UINT32/32bit boundry.
//
PayloadXdr = (UINT8 *)ALIGN_POINTER (PayloadXdr, sizeof (UINT32));
}
*EntryList = XdrEntryArray;
*ListCount = Index;
Status = EFI_SUCCESS;
DEBUG_CODE (
DEBUG ((DEBUG_INFO, "ExtractuCodeCapsuleXdrData %x entries are found in payload\n", *ListCount));
for (Index = 0; Index < *ListCount; Index++) {
DEBUG ((DEBUG_INFO, "Index %x Offset %x, Size %x\n", Index, XdrEntryArray[Index].EntryPtr - (UINT8 *)Image, XdrEntryArray[Index].EntrySize));
}
);
FUNC_EXIT:
if (EFI_ERROR(Status)) {
DEBUG ((DEBUG_ERROR, "uCode Paylod Xdr Parsing error\n"));
FreePool(XdrEntryArray);
}
return Status;
}
/**
Update Version info FFS inside uCode FV.
uCode FV is orgnized as follwing rules
----------------------------
| FV Header |
----------------------------
| Optional Ext Header |
----------------------------
| Version FFS |
----------------------------
| Optional Pad FFS |
----------------------------
| uCode FFS |
----------------------------
During update, we can update FFS + Optional Pad FFS to store new Version FFS. but must keep uCode FFS unchanged
@param[In] VerInfoFFS The content of New VersionInf
@retval Version File Payload. The Microcode Version file content is returned.
**/
EFI_STATUS
UpdateVersionInfo (
INTEL_MICROCODE_VERSION_FFS_DATA *NewVersion,
UINTN NewVersionSize
)
{
EFI_STATUS Status;
UINT8 *uCodeFv;
UINTN Index;
UINTN VersionSize;
UINTN MaxVersionSize;
UINT8 *VersionAddr;
EFI_FFS_FILE_HEADER *uCodeFfsHdr;
EFI_FFS_FILE_HEADER *VersionFfsHdr;
uCodeFfsHdr = NULL;
VersionFfsHdr = NULL;
uCodeFv = NULL;
//
// Use SPI read instead of MMIO read bicoz we are using TopSwap. and MMIO is mapping to LastKnownGood
//
uCodeFv = AllocateZeroPool(PcdGet32(PcdFlashNvStorageMicrocodeSize));
if (uCodeFv == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = FlashRead (
(UINT8 *)uCodeFv, //DATA
(UINT8 *)(UINTN)PcdGet32(PcdFlashNvStorageMicrocodeBase), //ADDRESS
PcdGet32(PcdFlashNvStorageMicrocodeSize) //LENGTH
);
if (EFI_ERROR(Status)) {
goto FUNC_EXIT;
}
//
// Search uCode array FFS Header
//
for (Index = 0; Index < PcdGet32(PcdFlashNvStorageMicrocodeSize); Index++) {
if (CompareGuid((EFI_GUID *)&uCodeFv[Index], &gIntelMicrocodeVersionFfsFileGuid)) {
break;
}
}
if (Index >= PcdGet32(PcdFlashNvStorageMicrocodeSize)) {
DEBUG ((DEBUG_ERROR, "Can't find Microcode Version FFS\n"));
ASSERT(FALSE);
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
VersionFfsHdr = (EFI_FFS_FILE_HEADER *)&uCodeFv[Index];
//
// Search uCode array FFS Header
//
for (Index = 0; Index < PcdGet32(PcdFlashNvStorageMicrocodeSize); Index++) {
if (CompareGuid((EFI_GUID *)&uCodeFv[Index], &gIntelMicrocodeArrayFfsFileGuid)) {
break;
}
}
if (Index >= PcdGet32(PcdFlashNvStorageMicrocodeSize)) {
DEBUG ((DEBUG_ERROR, "Can't find Microcode array FFS\n"));
ASSERT(FALSE);
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
uCodeFfsHdr = (EFI_FFS_FILE_HEADER *)&uCodeFv[Index];
if (uCodeFfsHdr->Type != EFI_FV_FILETYPE_RAW || VersionFfsHdr->Type != EFI_FV_FILETYPE_RAW) {
DEBUG ((DEBUG_ERROR, "Can't find Microcode Version FFS\n"));
ASSERT(FALSE);
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
if (IS_FFS_FILE2 (VersionFfsHdr)) {
VersionSize = FFS_FILE2_SIZE (VersionFfsHdr) - sizeof(EFI_FFS_FILE_HEADER2);
VersionAddr = (UINT8 *)VersionFfsHdr + sizeof (EFI_FFS_FILE_HEADER2);
MaxVersionSize = (UINTN)(PHYSICAL_ADDRESS)((UINT8 *)uCodeFfsHdr - (UINT8 *)VersionFfsHdr) - sizeof(EFI_FFS_FILE_HEADER2);
} else {
VersionSize = FFS_FILE_SIZE (VersionFfsHdr) - sizeof(EFI_FFS_FILE_HEADER); //0x40- 0x18 = 0x28
VersionAddr = (UINT8 *)VersionFfsHdr + sizeof (EFI_FFS_FILE_HEADER); //sizeof (EFI_FFS_FILE_HEADER) = 0x18
MaxVersionSize = (UINTN)(PHYSICAL_ADDRESS)((UINT8 *)uCodeFfsHdr - (UINT8 *)VersionFfsHdr) - sizeof(EFI_FFS_FILE_HEADER); //0xf88
}
//
// Update Version FFS based on current situation
//
if (NewVersionSize <= VersionSize) {
//
// New version content is smaller, Update Version data and mask remaing tail to all Zero
// Do not update current Version FFS Header
//
CopyMem(VersionAddr, NewVersion, NewVersionSize);
ZeroMem(VersionAddr + NewVersionSize, VersionSize - NewVersionSize);
MicrocodeFlashWrite((UINTN)PcdGet32(PcdFlashNvStorageMicrocodeBase) + VersionAddr - uCodeFv, VersionAddr, VersionSize);
} else if (NewVersionSize <= MaxVersionSize) {
//
// New version content is bigger. Expand version file to a bigger one
//
if (IS_FFS_FILE2 (VersionFfsHdr)) {
((EFI_FFS_FILE_HEADER2 *)VersionFfsHdr)->ExtendedSize = (UINT64)(MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER2));
} else {
VersionFfsHdr->Size[0] = (UINT8)((MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER)) & 0xFF);
VersionFfsHdr->Size[1] = (UINT8)(((MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER)) & 0xFF00) >> 8);
VersionFfsHdr->Size[2] = (UINT8)(((MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER)) & 0xFF0000) >> 16);
}
//
// Todo: Still need to check FFS_ATTRIB_CHECKSUM Attribute.
// Now assume this attribute bit is 0. CHECKSU Checksum.File = 0xAA
// Re-calcutate check sum bicoz size is changed
//
if ((VersionFfsHdr->Attributes & FFS_ATTRIB_CHECKSUM) == 0) {
VersionFfsHdr->IntegrityCheck.Checksum.Header = GetHeaderChecksum(VersionFfsHdr);
} else {
DEBUG ((DEBUG_ERROR, "Attribute FFS_ATTRIB_CHECKSUM not supported\n"));
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
CopyMem(VersionAddr, NewVersion, NewVersionSize);
ZeroMem(VersionAddr + NewVersionSize, MaxVersionSize - NewVersionSize);
//
// Update entire Version FFS. Not its size changed to MaxVersionSize + FFS Header
//
if (IS_FFS_FILE2 (VersionFfsHdr)) {
MicrocodeFlashWrite(PcdGet32(PcdFlashNvStorageMicrocodeBase) + (UINT8 *)VersionFfsHdr - uCodeFv, VersionFfsHdr, MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER2));
} else {
MicrocodeFlashWrite(PcdGet32(PcdFlashNvStorageMicrocodeBase) + (UINT8 *)VersionFfsHdr - uCodeFv, VersionFfsHdr, MaxVersionSize + sizeof (EFI_FFS_FILE_HEADER));
}
} else {
DEBUG ((DEBUG_ERROR, "Microcode Version FFS size 0x%x is bigger than MaxSize %x\n", NewVersionSize, MaxVersionSize));
ASSERT(FALSE);
Status = EFI_INVALID_PARAMETER;
}
FUNC_EXIT:
if (uCodeFv != NULL) {
FreePool(uCodeFv);
}
return Status;
}
/**
Get Microcode Version File Data. Caller is responsible for freeing this resource
@param[out] MicrocodePatchAddress The address of Microcode
@param[out] MicrocodePatchRegionSize The region size of Microcode
@retval Version File Payload. The Microcode Version file content is returned.
**/
EFI_STATUS
GetMicrocodeRegionVersionInfo (
OUT UINT8 **VersionInfo,
OUT UINTN *VersionInfoSize
)
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN NumberOfHandles;
EFI_FV_FILETYPE FileType;
UINT32 FvStatus;
EFI_FV_FILE_ATTRIBUTES Attributes;
UINTN Size;
UINTN Index;
EFI_FIRMWARE_VOLUME2_PROTOCOL *FvInstance;
UINT8 *DataBuf;
DataBuf = NULL;
*VersionInfo = NULL;
*VersionInfoSize = 0;
//
// Locate FV protocol.
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolume2ProtocolGuid,
NULL,
&NumberOfHandles,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
//
// Defined errors at this time are not found and out of resources.
//
return Status;
}
//
// Looking for uCode FVB
//
for (Index = 0; Index < NumberOfHandles; Index++) {
//
// Get the protocol on this handle
// This should not fail because of LocateHandleBuffer
//
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiFirmwareVolume2ProtocolGuid,
(VOID**) &FvInstance
);
ASSERT_EFI_ERROR (Status);
DEBUG_CODE(
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;
EFI_PHYSICAL_ADDRESS BaseAddr;
BaseAddr = 0;
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiFirmwareVolumeBlockProtocolGuid,
(VOID**) &Fvb
);
Fvb->GetPhysicalAddress(Fvb, &BaseAddr);
DEBUG ((DEBUG_ERROR, "FVB BaseAddress 0x%x\n", BaseAddr));
);
//
// See if it has the Fmp Version File storage file
//
Status = FvInstance->ReadFile (
FvInstance,
&gIntelMicrocodeVersionFfsFileGuid,
NULL,
&Size,
&FileType,
&Attributes,
&FvStatus
);
//
// Found and file attribute is correct
//
if (Status == EFI_SUCCESS && FileType == EFI_FV_FILETYPE_RAW && Size >= sizeof(INTEL_MICROCODE_VERSION_FFS_DATA)) {
DataBuf = AllocatePool(Size);
break;
}
}
if (DataBuf != NULL) {
Status = FvInstance->ReadFile (
FvInstance,
&gIntelMicrocodeVersionFfsFileGuid,
&DataBuf,
&Size,
&FileType,
&Attributes,
&FvStatus
);
ASSERT_EFI_ERROR(Status);
*VersionInfo = DataBuf;
*VersionInfoSize = Size;
DEBUG ((DEBUG_INFO, "Found Version file for uCode Region\n"));
}
//
// Free any allocated buffers
//
gBS->FreePool (HandleBuffer);
return Status;
}
/**
Get Microcode update signature of currently loaded Microcode update.
@return Microcode signature.
**/
UINT32
GetCurrentMicrocodeSignature (
VOID
)
{
MSR_IA32_BIOS_SIGN_ID_REGISTER MsrSignId;
AsmWriteMsr64 (MSR_IA32_BIOS_SIGN_ID, 0);
AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, NULL, NULL);
MsrSignId.Uint64 = AsmReadMsr64 (MSR_IA32_BIOS_SIGN_ID);
return MsrSignId.Bits.MicrocodeUpdateSignature;
}
/**
Get current processor signature.
@return current processor signature.
**/
UINT32
GetCurrentProcessorSignature (
VOID
)
{
UINT32 RegEax;
AsmCpuid(CPUID_VERSION_INFO, &RegEax, NULL, NULL, NULL);
return RegEax;
}
/**
Get current platform ID.
@return current platform ID.
**/
UINT8
GetCurrentPlatformId (
VOID
)
{
UINT8 PlatformId;
PlatformId = (UINT8)AsmMsrBitFieldRead64(MSR_IA32_PLATFORM_ID, 50, 52);
return PlatformId;
}
/**
Load new Microcode.
@param[in] Address The address of new Microcode.
@return Loaded Microcode signature.
**/
UINT32
LoadMicrocode (
IN UINT64 Address
)
{
AsmWriteMsr64(MSR_IA32_BIOS_UPDT_TRIG, Address);
return GetCurrentMicrocodeSignature();
}
/**
Load Microcode on an Application Processor.
The function prototype for invoking a function on an Application Processor.
@param[in,out] Buffer The pointer to private data buffer.
**/
VOID
EFIAPI
MicrocodeLoadAp (
IN OUT VOID *Buffer
)
{
MICROCODE_LOAD_BUFFER *MicrocodeLoadBuffer;
MicrocodeLoadBuffer = Buffer;
MicrocodeLoadBuffer->Revision = LoadMicrocode (MicrocodeLoadBuffer->Address);
}
/**
Load new Microcode on this processor
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] CpuIndex The index of the processor.
@param[in] Address The address of new Microcode.
@return Loaded Microcode signature.
**/
UINT32
LoadMicrocodeOnThis (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN UINTN CpuIndex,
IN UINT64 Address
)
{
EFI_STATUS Status;
EFI_MP_SERVICES_PROTOCOL *MpService;
MICROCODE_LOAD_BUFFER MicrocodeLoadBuffer;
if (CpuIndex == MicrocodeFmpPrivate->BspIndex) {
return LoadMicrocode (Address);
} else {
MpService = MicrocodeFmpPrivate->MpService;
MicrocodeLoadBuffer.Address = Address;
MicrocodeLoadBuffer.Revision = 0;
Status = MpService->StartupThisAP (
MpService,
MicrocodeLoadAp,
CpuIndex,
NULL,
0,
&MicrocodeLoadBuffer,
NULL
);
ASSERT_EFI_ERROR(Status);
return MicrocodeLoadBuffer.Revision;
}
}
/**
Collect processor information.
The function prototype for invoking a function on an Application Processor.
@param[in,out] Buffer The pointer to private data buffer.
**/
VOID
EFIAPI
CollectProcessorInfo (
IN OUT VOID *Buffer
)
{
PROCESSOR_INFO *ProcessorInfo;
ProcessorInfo = Buffer;
ProcessorInfo->ProcessorSignature = GetCurrentProcessorSignature();
ProcessorInfo->PlatformId = GetCurrentPlatformId();
ProcessorInfo->ProcessorFlags = 1 << ProcessorInfo->PlatformId;
ProcessorInfo->MicrocodeRevision = GetCurrentMicrocodeSignature();
}
/**
Get current Microcode information.
The ProcessorInformation (BspIndex/ProcessorCount/ProcessorInfo)
in MicrocodeFmpPrivate must be initialized.
The MicrocodeInformation (DescriptorCount/ImageDescriptor/MicrocodeInfo)
in MicrocodeFmpPrivate may not be avaiable in this function.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] DescriptorCount The count of Microcode ImageDescriptor allocated.
@param[out] ImageDescriptor Microcode ImageDescriptor
@param[out] MicrocodeInfo Microcode information
@return Microcode count
**/
UINTN
GetMicrocodeInfo (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN UINTN DescriptorCount, OPTIONAL
OUT EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor, OPTIONAL
OUT MICROCODE_INFO *MicrocodeInfo OPTIONAL
)
{
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
CPU_MICROCODE_HEADER *MicrocodeEntryPoint;
UINTN MicrocodeEnd;
UINTN TotalSize;
UINTN Count;
UINT64 ImageAttributes;
BOOLEAN IsInUse;
EFI_STATUS Status;
UINT32 AttemptStatus;
UINTN TargetCpuIndex;
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
DEBUG ((DEBUG_INFO, "Microcode Region - 0x%x - 0x%x\n", MicrocodePatchAddress, MicrocodePatchRegionSize));
Count = 0;
MicrocodeEnd = (UINTN)MicrocodePatchAddress + MicrocodePatchRegionSize;
MicrocodeEntryPoint = (CPU_MICROCODE_HEADER *) (UINTN) MicrocodePatchAddress;
do {
if (MicrocodeEntryPoint->HeaderVersion == 0x1 && MicrocodeEntryPoint->LoaderRevision == 0x1) {
//
// It is the microcode header. It is not the padding data between microcode patches
// becasue the padding data should not include 0x00000001 and it should be the repeated
// byte format (like 0xXYXYXYXY....).
//
if (MicrocodeEntryPoint->DataSize == 0) {
TotalSize = 2048;
} else {
TotalSize = MicrocodeEntryPoint->TotalSize;
}
TargetCpuIndex = (UINTN)-1;
Status = VerifyMicrocode(MicrocodeFmpPrivate, MicrocodeEntryPoint, TotalSize, FALSE, &AttemptStatus, NULL, &TargetCpuIndex);
if (!EFI_ERROR(Status)) {
IsInUse = TRUE;
ASSERT (TargetCpuIndex < MicrocodeFmpPrivate->ProcessorCount);
MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].MicrocodeIndex = Count;
//
// Always update logic CPU MicrocodeRevision with highest Supported Microcode Version.
// This logic complies with Physical CPU uCode patching logic
//
if (!MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].IsRealCpu) {
if ((MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].MicrocodeRevision == (UINT32)-1) ||
(MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].MicrocodeRevision < MicrocodeEntryPoint->UpdateRevision)) {
MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].MicrocodeRevision = MicrocodeEntryPoint->UpdateRevision;
}
}
} else {
IsInUse = FALSE;
}
if (ImageDescriptor != NULL && DescriptorCount > Count) {
ImageDescriptor[Count].ImageIndex = (UINT8)(Count + 1);
CopyGuid (&ImageDescriptor[Count].ImageTypeId, PcdGetPtr(PcdWindowsUcodeFirmwareCapsuleGuid));
ImageDescriptor[Count].ImageId = LShiftU64(MicrocodeEntryPoint->ProcessorFlags, 32) + MicrocodeEntryPoint->ProcessorSignature.Uint32;
ImageDescriptor[Count].ImageIdName = NULL;
ImageDescriptor[Count].Version = MicrocodeEntryPoint->UpdateRevision;
ImageDescriptor[Count].VersionName = NULL;
ImageDescriptor[Count].Size = TotalSize;
ImageAttributes = IMAGE_ATTRIBUTE_IMAGE_UPDATABLE | IMAGE_ATTRIBUTE_RESET_REQUIRED;
if (IsInUse) {
ImageAttributes |= IMAGE_ATTRIBUTE_IN_USE;
}
ImageDescriptor[Count].AttributesSupported = ImageAttributes | IMAGE_ATTRIBUTE_IN_USE;
ImageDescriptor[Count].AttributesSetting = ImageAttributes;
ImageDescriptor[Count].Compatibilities = 0;
ImageDescriptor[Count].LowestSupportedImageVersion = MicrocodeEntryPoint->UpdateRevision; // do not support rollback
ImageDescriptor[Count].LastAttemptVersion = 0;
ImageDescriptor[Count].LastAttemptStatus = 0;
ImageDescriptor[Count].HardwareInstance = 0;
}
if (MicrocodeInfo != NULL && DescriptorCount > Count) {
MicrocodeInfo[Count].MicrocodeEntryPoint = MicrocodeEntryPoint;
MicrocodeInfo[Count].TotalSize = TotalSize;
MicrocodeInfo[Count].InUse = IsInUse;
}
} else {
//
// It is the padding data between the microcode patches for microcode patches alignment.
// Because the microcode patch is the multiple of 1-KByte, the padding data should not
// exist if the microcode patch alignment value is not larger than 1-KByte. So, the microcode
// alignment value should be larger than 1-KByte. We could skip SIZE_4KB padding data to
// find the next possible microcode patch header.
//
MicrocodeEntryPoint = (CPU_MICROCODE_HEADER *) (((UINTN) MicrocodeEntryPoint) + SIZE_1KB);
continue;
}
Count++;
ASSERT(Count < 0xFF);
//
// Get the next patch.
//
MicrocodeEntryPoint = (CPU_MICROCODE_HEADER *) (((UINTN) MicrocodeEntryPoint) + TotalSize);
} while (((UINTN) MicrocodeEntryPoint < MicrocodeEnd));
return Count;
}
/**
Return matched processor information.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] ProcessorSignature The processor signature to be matched
@param[in] ProcessorFlags The processor flags to be matched
@param[in, out] TargetCpuIndex On input, the index of target CPU which tries to match the Microcode. (UINTN)-1 means to try all.
On output, the index of target CPU which matches the Microcode.
@return matched processor information.
**/
PROCESSOR_INFO *
GetMatchedProcessor (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN UINT32 ProcessorSignature,
IN UINT32 ProcessorFlags,
IN OUT UINTN *TargetCpuIndex
)
{
UINTN Index;
if (*TargetCpuIndex != (UINTN)-1) {
Index = *TargetCpuIndex;
if (ProcessorSignature == MicrocodeFmpPrivate->ProcessorInfo[Index].ProcessorSignature &&
(ProcessorFlags & MicrocodeFmpPrivate->ProcessorInfo[Index].ProcessorFlags) != 0) {
return &MicrocodeFmpPrivate->ProcessorInfo[Index];
} else {
return NULL;
}
}
for (Index = 0; Index < MicrocodeFmpPrivate->ProcessorCount; Index++) {
if ((ProcessorSignature == MicrocodeFmpPrivate->ProcessorInfo[Index].ProcessorSignature) &&
((ProcessorFlags & MicrocodeFmpPrivate->ProcessorInfo[Index].ProcessorFlags) != 0)) {
*TargetCpuIndex = Index;
return &MicrocodeFmpPrivate->ProcessorInfo[Index];
}
}
return NULL;
}
/**
Verify Microcode.
if the uCode fails check sum. or version is lower than any of the processor that matches signature and flags
Or tryload == TRUE but uCode fails CPU authentication. Microcode verification fails
Caution: This function may receive untrusted input.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[in] TryLoad Try to load Microcode or not.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] AbortReason A pointer to a pointer to a null-terminated string providing more
details for the aborted operation. The buffer is allocated by this function
with AllocatePool(), and it is the caller's responsibility to free it with a
call to FreePool().
@param[in, out] TargetCpuIndex On input, the index of target CPU which tries to match the Microcode. (UINTN)-1 means to try all.
On output, the index of target CPU which matches the Microcode.
@retval EFI_SUCCESS The Microcode image passes verification.
@retval EFI_VOLUME_CORRUPTED The Microcode image is corrupted.
@retval EFI_INCOMPATIBLE_VERSION The Microcode image version is incorrect.
@retval EFI_UNSUPPORTED The Microcode ProcessorSignature or ProcessorFlags is incorrect.
@retval EFI_SECURITY_VIOLATION The Microcode image fails to load.
**/
EFI_STATUS
VerifyMicrocode (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN VOID *Image,
IN UINTN ImageSize,
IN BOOLEAN TryLoad,
OUT UINT32 *LastAttemptStatus,
OUT CHAR16 **AbortReason, OPTIONAL
IN OUT UINTN *TargetCpuIndex
)
{
UINTN Index;
CPU_MICROCODE_HEADER *MicrocodeEntryPoint;
UINTN TotalSize;
UINTN DataSize;
UINT32 CurrentRevision;
PROCESSOR_INFO *ProcessorInfo;
UINT32 CheckSum32;
UINT32 InCompleteSum32;
UINTN ExtendedTableLength;
UINT32 ExtendedTableCount;
CPU_MICROCODE_EXTENDED_TABLE *ExtendedTable;
CPU_MICROCODE_EXTENDED_TABLE_HEADER *ExtendedTableHeader;
BOOLEAN CorrectMicrocode;
//
// Check HeaderVersion
//
MicrocodeEntryPoint = Image;
if (MicrocodeEntryPoint->HeaderVersion != 0x1) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on HeaderVersion\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidHeaderVersion"), L"InvalidHeaderVersion");
}
return EFI_INCOMPATIBLE_VERSION;
}
//
// Check LoaderRevision
//
if (MicrocodeEntryPoint->LoaderRevision != 0x1) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on LoaderRevision\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidLoaderVersion"), L"InvalidLoaderVersion");
}
return EFI_INCOMPATIBLE_VERSION;
}
//
// Check TotalSize
//
if (MicrocodeEntryPoint->DataSize == 0) {
TotalSize = 2048;
} else {
TotalSize = MicrocodeEntryPoint->TotalSize;
}
if (TotalSize <= sizeof(CPU_MICROCODE_HEADER)) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - TotalSize too small\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidTotalSize"), L"InvalidTotalSize");
}
return EFI_VOLUME_CORRUPTED;
}
if ((TotalSize & (SIZE_1KB - 1)) != 0) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - TotalSize is not multiples of 1024 bytes (1 KBytes)\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidTotalSize"), L"InvalidTotalSize");
}
return EFI_VOLUME_CORRUPTED;
}
if (TotalSize != ImageSize) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - TotalSize not equal to ImageSize\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidTotalSize"), L"InvalidTotalSize");
}
return EFI_VOLUME_CORRUPTED;
}
//
// Check DataSize
//
if (MicrocodeEntryPoint->DataSize == 0) {
DataSize = 2048 - sizeof(CPU_MICROCODE_HEADER);
} else {
DataSize = MicrocodeEntryPoint->DataSize;
}
if (DataSize > TotalSize - sizeof(CPU_MICROCODE_HEADER)) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - DataSize too big\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidDataSize"), L"InvalidDataSize");
}
return EFI_VOLUME_CORRUPTED;
}
if ((DataSize & 0x3) != 0) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - DataSize is not multiples of DWORDs\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidDataSize"), L"InvalidDataSize");
}
return EFI_VOLUME_CORRUPTED;
}
//
// Check CheckSum32
//
CheckSum32 = CalculateSum32((UINT32 *)MicrocodeEntryPoint, DataSize + sizeof(CPU_MICROCODE_HEADER));
if (CheckSum32 != 0) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on CheckSum32\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidChecksum"), L"InvalidChecksum");
}
return EFI_VOLUME_CORRUPTED;
}
InCompleteSum32 = CheckSum32;
InCompleteSum32 -= MicrocodeEntryPoint->ProcessorSignature.Uint32;
InCompleteSum32 -= MicrocodeEntryPoint->ProcessorFlags;
InCompleteSum32 -= MicrocodeEntryPoint->Checksum;
//
// Check ProcessorSignature/ProcessorFlags
//
ProcessorInfo = GetMatchedProcessor (MicrocodeFmpPrivate, MicrocodeEntryPoint->ProcessorSignature.Uint32, MicrocodeEntryPoint->ProcessorFlags, TargetCpuIndex);
if (ProcessorInfo == NULL) {
CorrectMicrocode = FALSE;
ExtendedTableLength = TotalSize - (DataSize + sizeof(CPU_MICROCODE_HEADER));
if (ExtendedTableLength != 0) {
//
// Extended Table exist, check if the CPU in support list
//
ExtendedTableHeader = (CPU_MICROCODE_EXTENDED_TABLE_HEADER *)((UINT8 *)(MicrocodeEntryPoint) + DataSize + sizeof(CPU_MICROCODE_HEADER));
//
// Calculate Extended Checksum
//
if ((ExtendedTableLength > sizeof(CPU_MICROCODE_EXTENDED_TABLE_HEADER)) && ((ExtendedTableLength & 0x3) == 0)) {
CheckSum32 = CalculateSum32((UINT32 *)ExtendedTableHeader, ExtendedTableLength);
if (CheckSum32 != 0) {
//
// Checksum incorrect
//
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - The checksum for extended table is incorrect\n"));
} else {
//
// Checksum correct
//
ExtendedTableCount = ExtendedTableHeader->ExtendedSignatureCount;
if (ExtendedTableCount > (ExtendedTableLength - sizeof(CPU_MICROCODE_EXTENDED_TABLE_HEADER)) / sizeof(CPU_MICROCODE_EXTENDED_TABLE)) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - ExtendedTableCount too big\n"));
} else {
ExtendedTable = (CPU_MICROCODE_EXTENDED_TABLE *)(ExtendedTableHeader + 1);
for (Index = 0; Index < ExtendedTableCount; Index++) {
CheckSum32 = InCompleteSum32;
CheckSum32 += ExtendedTable->ProcessorSignature.Uint32;
CheckSum32 += ExtendedTable->ProcessorFlag;
CheckSum32 += ExtendedTable->Checksum;
if (CheckSum32 != 0) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - The checksum for ExtendedTable entry with index 0x%x is incorrect\n", Index));
} else {
//
// Verify Header
//
ProcessorInfo = GetMatchedProcessor (MicrocodeFmpPrivate, ExtendedTable->ProcessorSignature.Uint32, ExtendedTable->ProcessorFlag, TargetCpuIndex);
if (ProcessorInfo != NULL) {
//
// Find one
//
CorrectMicrocode = TRUE;
break;
}
}
ExtendedTable++;
}
}
}
}
}
if (!CorrectMicrocode) {
if (TryLoad) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on Current ProcessorSignature/ProcessorFlags\n"));
}
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"UnsupportedProcessorSignature/ProcessorFlags"), L"UnsupportedProcessorSignature/ProcessorFlags");
}
return EFI_UNSUPPORTED;
}
}
//
// Regard same revision as processor CurrentRevion can pass verification.
// Caller can double filter this case outside VerifyMicrocde
//
CurrentRevision = ProcessorInfo->MicrocodeRevision;
if ((CurrentRevision != (UINT32)-1) && (MicrocodeEntryPoint->UpdateRevision < CurrentRevision)) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on UpdateRevision\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"IncorrectRevision"), L"IncorrectRevision");
}
return EFI_INCOMPATIBLE_VERSION;
}
//
// Check UpdateRevision and Load MCU when CPU is real hardware.
// If CPU definition comes from uCode Policy PCD, do not TryLoad
//
if (ProcessorInfo->IsRealCpu && TryLoad) {
CurrentRevision = LoadMicrocodeOnThis(MicrocodeFmpPrivate, ProcessorInfo->CpuIndex, (UINTN)MicrocodeEntryPoint + sizeof(CPU_MICROCODE_HEADER));
if (MicrocodeEntryPoint->UpdateRevision != CurrentRevision) {
DEBUG ((DEBUG_ERROR, "VerifyMicrocode - fail on LoadMicrocode\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR;
if (AbortReason != NULL) {
*AbortReason = AllocateCopyPool(sizeof(L"InvalidData"), L"InvalidData");
}
return EFI_SECURITY_VIOLATION;
}
}
return EFI_SUCCESS;
}
/**
Get next Microcode entrypoint.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] MicrocodeEntryPoint Current Microcode entrypoint
@return next Microcode entrypoint.
**/
CPU_MICROCODE_HEADER *
GetNextMicrocode (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN CPU_MICROCODE_HEADER *MicrocodeEntryPoint
)
{
UINTN Index;
for (Index = 0; Index < MicrocodeFmpPrivate->DescriptorCount; Index++) {
if (MicrocodeEntryPoint == MicrocodeFmpPrivate->MicrocodeInfo[Index].MicrocodeEntryPoint) {
if (Index == (UINTN)MicrocodeFmpPrivate->DescriptorCount - 1) {
// it is last one
return NULL;
} else {
// return next one
return MicrocodeFmpPrivate->MicrocodeInfo[Index + 1].MicrocodeEntryPoint;
}
}
}
ASSERT(FALSE);
return NULL;
}
/**
Get next FIT Microcode entrypoint.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] MicrocodeEntryPoint Current Microcode entrypoint
@return next FIT Microcode entrypoint.
**/
CPU_MICROCODE_HEADER *
GetNextFitMicrocode (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN CPU_MICROCODE_HEADER *MicrocodeEntryPoint
)
{
UINTN Index;
for (Index = 0; Index < MicrocodeFmpPrivate->FitMicrocodeEntryCount; Index++) {
if (MicrocodeEntryPoint == MicrocodeFmpPrivate->FitMicrocodeInfo[Index].MicrocodeEntryPoint) {
if (Index == (UINTN) MicrocodeFmpPrivate->FitMicrocodeEntryCount - 1) {
// it is last one
return NULL;
} else {
// return next one
return MicrocodeFmpPrivate->FitMicrocodeInfo[Index + 1].MicrocodeEntryPoint;
}
}
}
ASSERT(FALSE);
return NULL;
}
/**
Find empty FIT Microcode entrypoint.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] AvailableSize Available size of the empty FIT Microcode entrypoint.
@return Empty FIT Microcode entrypoint.
**/
CPU_MICROCODE_HEADER *
FindEmptyFitMicrocode (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN UINTN ImageSize,
OUT UINTN *AvailableSize
)
{
UINTN Index;
CPU_MICROCODE_HEADER *MicrocodeEntryPoint;
CPU_MICROCODE_HEADER *NextMicrocodeEntryPoint;
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
for (Index = 0; Index < MicrocodeFmpPrivate->FitMicrocodeEntryCount; Index++) {
if (MicrocodeFmpPrivate->FitMicrocodeInfo[Index].Empty) {
MicrocodeEntryPoint = MicrocodeFmpPrivate->FitMicrocodeInfo[Index].MicrocodeEntryPoint;
NextMicrocodeEntryPoint = GetNextFitMicrocode (MicrocodeFmpPrivate, MicrocodeEntryPoint);
if (NextMicrocodeEntryPoint != NULL) {
*AvailableSize = (UINTN) NextMicrocodeEntryPoint - (UINTN) MicrocodeEntryPoint;
} else {
*AvailableSize = (UINTN) MicrocodePatchAddress + MicrocodePatchRegionSize - (UINTN) MicrocodeEntryPoint;
}
if (*AvailableSize >= ImageSize) {
return MicrocodeEntryPoint;
}
}
}
return NULL;
}
/**
Find unused FIT Microcode entrypoint.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] AvailableSize Available size of the unused FIT Microcode entrypoint.
@return Unused FIT Microcode entrypoint.
**/
CPU_MICROCODE_HEADER *
FindUnusedFitMicrocode (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN UINTN ImageSize,
OUT UINTN *AvailableSize
)
{
UINTN Index;
UINTN CpuIndex;
CPU_MICROCODE_HEADER *MicrocodeEntryPoint;
CPU_MICROCODE_HEADER *NextMicrocodeEntryPoint;
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
//
// Get uCode Slot that doesn't match uCode selection Policy
//
for (Index = 0; Index < MicrocodeFmpPrivate->FitMicrocodeEntryCount; Index++) {
//
// If uCode in FIT slot matches uCode selection policy PCD, skip over it
//
for (CpuIndex = 0; CpuIndex < MicrocodeFmpPrivate->ProcessorCount; CpuIndex++) {
if (MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].MicrocodeIndex == Index) {
break;
}
}
if (CpuIndex < MicrocodeFmpPrivate->ProcessorCount) {
continue;
}
MicrocodeEntryPoint = MicrocodeFmpPrivate->FitMicrocodeInfo[Index].MicrocodeEntryPoint;
NextMicrocodeEntryPoint = GetNextFitMicrocode (MicrocodeFmpPrivate, MicrocodeEntryPoint);
if (NextMicrocodeEntryPoint != NULL) {
*AvailableSize = (UINTN) NextMicrocodeEntryPoint - (UINTN) MicrocodeEntryPoint;
} else {
*AvailableSize = (UINTN) MicrocodePatchAddress + MicrocodePatchRegionSize - (UINTN) MicrocodeEntryPoint;
}
if (*AvailableSize >= ImageSize) {
return MicrocodeEntryPoint;
}
}
DEBUG ((DEBUG_INFO, "Can't find right uCode slot that doesn't match uCode Selection Policy\n"));
return NULL;
}
/**
Get current Microcode used region size.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@return current Microcode used region size.
**/
UINTN
GetCurrentMicrocodeUsedRegionSize (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
if (MicrocodeFmpPrivate->DescriptorCount == 0) {
return 0;
}
return (UINTN)MicrocodeFmpPrivate->MicrocodeInfo[MicrocodeFmpPrivate->DescriptorCount - 1].MicrocodeEntryPoint
+ (UINTN)MicrocodeFmpPrivate->MicrocodeInfo[MicrocodeFmpPrivate->DescriptorCount - 1].TotalSize
- (UINTN)MicrocodeFmpPrivate->MicrocodePatchAddress;
}
/**
Update Microcode.
@param[in] Address The flash address of Microcode.
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@retval EFI_SUCCESS The Microcode image is updated.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
UpdateMicrocode (
IN UINT64 Address,
IN VOID *Image,
IN UINTN ImageSize,
OUT UINT32 *LastAttemptStatus,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
EFI_STATUS Status;
DEBUG ((DEBUG_INFO, "PlatformUpdate:"));
DEBUG ((DEBUG_INFO, " Address - 0x%lx,", Address));
DEBUG ((DEBUG_INFO, " Length - 0x%x\n", ImageSize));
Status = MicrocodeFlashWrite (
Address,
Image,
ImageSize
);
if (!EFI_ERROR(Status)) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;
} else {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
}
return Status;
}
/**
Update Microcode flash region with FIT.
ToDo: skip reclaim. Reclaim could corrupt entire ucode range
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] TargetMicrocodeEntryPoint Target Microcode entrypoint to be updated
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
UpdateMicrocodeFlashRegionWithFit (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN CPU_MICROCODE_HEADER *TargetMicrocodeEntryPoint,
IN VOID *Image,
IN UINTN ImageSize,
IN VOID *NewVersion, OPTIONAL
IN UINTN NewVersionSize, OPTIONAL
OUT UINT32 *LastAttemptStatus,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
UINTN TargetTotalSize;
EFI_STATUS Status;
VOID *MicrocodePatchScratchBuffer;
UINT8 *ScratchBufferPtr;
UINTN ScratchBufferSize;
UINTN RestSize;
UINTN AvailableSize;
VOID *NextMicrocodeEntryPoint;
VOID *EmptyFitMicrocodeEntry;
VOID *UnusedFitMicrocodeEntry;
DEBUG ((DEBUG_INFO, "UpdateMicrocodeFlashRegionWithFit: Image - 0x%x, size - 0x%x\n", Image, ImageSize));
SetUpdateProgress (UpdatinguCode, 71);
Progress(71);
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
MicrocodePatchScratchBuffer = AllocateZeroPool (MicrocodePatchRegionSize);
if (MicrocodePatchScratchBuffer == NULL) {
DEBUG ((DEBUG_ERROR, "Fail to allocate Microcode Scratch buffer\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
return EFI_OUT_OF_RESOURCES;
}
ScratchBufferPtr = MicrocodePatchScratchBuffer;
ScratchBufferSize = 0;
//
// Step 2. Update uCode Major region.
//
// Target data collection
//
TargetTotalSize = 0;
AvailableSize = 0;
if (TargetMicrocodeEntryPoint != NULL) {
if (TargetMicrocodeEntryPoint->DataSize == 0) {
TargetTotalSize = 2048;
} else {
TargetTotalSize = TargetMicrocodeEntryPoint->TotalSize;
}
DEBUG ((DEBUG_INFO, " TargetTotalSize - 0x%x\n", TargetTotalSize));
NextMicrocodeEntryPoint = GetNextFitMicrocode (MicrocodeFmpPrivate, TargetMicrocodeEntryPoint);
DEBUG ((DEBUG_INFO, " NextMicrocodeEntryPoint - 0x%x\n", NextMicrocodeEntryPoint));
if (NextMicrocodeEntryPoint != NULL) {
ASSERT ((UINTN) NextMicrocodeEntryPoint >= ((UINTN) TargetMicrocodeEntryPoint + TargetTotalSize));
AvailableSize = (UINTN) NextMicrocodeEntryPoint - (UINTN) TargetMicrocodeEntryPoint;
} else {
AvailableSize = (UINTN) MicrocodePatchAddress + MicrocodePatchRegionSize - (UINTN) TargetMicrocodeEntryPoint;
}
DEBUG ((DEBUG_INFO, " AvailableSize - 0x%x\n", AvailableSize));
ASSERT (AvailableSize >= TargetTotalSize);
}
//
// Total Size means the Microcode size.
// Available Size means the Microcode size plus the pad till (1) next Microcode or (2) the end.
//
// (1)
// +------+-----------+-----+------+===================+
// | MCU1 | Microcode | PAD | MCU2 | Empty |
// +------+-----------+-----+------+===================+
// | TotalSize |
// |<-AvailableSize->|
//
// (2)
// +------+-----------+===================+
// | MCU | Microcode | Empty |
// +------+-----------+===================+
// | TotalSize |
// |<- AvailableSize ->|
//
//
// Update based on policy
//
//
// 1. If there is enough space to override old one in situ, replace old microcode in situ.
//
if (AvailableSize >= ImageSize) {
DEBUG ((DEBUG_INFO, "Replace old microcode in situ\n"));
//
// +------+------------+------+===================+
// |Other | Old Image | ... | Empty |
// +------+------------+------+===================+
//
// +------+---------+--+------+===================+
// |Other |New Image|FF| ... | Empty |
// +------+---------+--+------+===================+
//
// 1.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 1.2. Pad 0xFF
RestSize = AvailableSize - ImageSize;
if (RestSize > 0) {
SetMem (ScratchBufferPtr, RestSize, 0xFF);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode(
(UINTN)TargetMicrocodeEntryPoint,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
goto CONTEXT_CLEAR;
}
//
// 2. If there is empty FIT microcode entry with enough space, use it.
//
EmptyFitMicrocodeEntry = FindEmptyFitMicrocode (MicrocodeFmpPrivate, ImageSize, &AvailableSize);
if (EmptyFitMicrocodeEntry != NULL) {
DEBUG ((DEBUG_INFO, "Use empty FIT microcode entry\n"));
// 2.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 2.2. Pad 0xFF
RestSize = AvailableSize - ImageSize;
if (RestSize > 0) {
SetMem (ScratchBufferPtr, RestSize, 0xFF);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode (
(UINTN) EmptyFitMicrocodeEntry,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
if (!EFI_ERROR (Status) && (TargetMicrocodeEntryPoint != NULL)) {
//
// Empty old microcode.
//
ScratchBufferPtr = MicrocodePatchScratchBuffer;
SetMem (ScratchBufferPtr, TargetTotalSize, 0xFF);
ScratchBufferSize = TargetTotalSize;
ScratchBufferPtr = (UINT8 *) MicrocodePatchScratchBuffer + ScratchBufferSize;
Status = UpdateMicrocode (
(UINTN) TargetMicrocodeEntryPoint,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
}
goto CONTEXT_CLEAR;
}
//
// 3. If there is unused microcode entry with enough space, use it.
//
UnusedFitMicrocodeEntry = FindUnusedFitMicrocode (MicrocodeFmpPrivate, ImageSize, &AvailableSize);
if (UnusedFitMicrocodeEntry != NULL) {
DEBUG ((DEBUG_INFO, "Use unused FIT microcode entry\n"));
// 3.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 3.2. Pad 0xFF
RestSize = AvailableSize - ImageSize;
if (RestSize > 0) {
SetMem (ScratchBufferPtr, RestSize, 0xFF);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode (
(UINTN) UnusedFitMicrocodeEntry,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
if (!EFI_ERROR (Status) && (TargetMicrocodeEntryPoint != NULL)) {
//
// Empty old microcode.
//
ScratchBufferPtr = MicrocodePatchScratchBuffer;
SetMem (ScratchBufferPtr, TargetTotalSize, 0xFF);
ScratchBufferSize = TargetTotalSize;
ScratchBufferPtr = (UINT8 *) MicrocodePatchScratchBuffer + ScratchBufferSize;
Status = UpdateMicrocode (
(UINTN) TargetMicrocodeEntryPoint,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
}
goto CONTEXT_CLEAR;
}
//
// 4. No usable FIT microcode entry
// It is an expected failure. Recovery to interrupted update is not supprted
//
DEBUG ((DEBUG_ERROR, "No usable FIT microcode entry\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
Status = EFI_OUT_OF_RESOURCES;
CONTEXT_CLEAR:
//
// 5. Update Version FFS if update succeed
//
if (!EFI_ERROR(Status)) {
if (NewVersion != NULL && NewVersionSize >= sizeof(INTEL_MICROCODE_VERSION_FFS_DATA)) {
Status = UpdateVersionInfo (
(INTEL_MICROCODE_VERSION_FFS_DATA *)NewVersion,
NewVersionSize
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "Update VersionFfs fail!\n"));
goto FUNC_EXIT;
}
DEBUG ((DEBUG_INFO, "Update VersionFfs succeed!\n"));
}
}
FUNC_EXIT:
//
// Todo: May need to add memory free for FIT case
//
//
if (MicrocodePatchScratchBuffer != NULL) {
FreePool(MicrocodePatchScratchBuffer);
}
return Status;
}
/**
Update Microcode flash region.
Todo: Ensure all Microcde are saved at 4KB boundary
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] TargetMicrocodeEntryPoint Target Microcode entrypoint to be updated
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
UpdateMicrocodeFlashRegion (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN CPU_MICROCODE_HEADER *TargetMicrocodeEntryPoint,
IN VOID *Image,
IN UINTN ImageSize,
OUT UINT32 *LastAttemptStatus,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
UINTN TargetTotalSize;
UINTN UsedRegionSize;
EFI_STATUS Status;
VOID *MicrocodePatchScratchBuffer;
UINT8 *ScratchBufferPtr;
UINTN ScratchBufferSize;
UINTN RestSize;
UINTN AvailableSize;
VOID *NextMicrocodeEntryPoint;
MICROCODE_INFO *MicrocodeInfo;
UINTN MicrocodeCount;
UINTN Index;
//EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION ProgressBarForegroundColor;
//ProgressBarForegroundColor.Raw = FixedPcdGet32(PcdFmpDeviceProgressColor);
DEBUG ((DEBUG_INFO, "UpdateMicrocodeFlashRegion: Image - 0x%x, size - 0x%x\n", Image, ImageSize));
SetUpdateProgress (UpdatinguCode, 71);
Progress(71);
//DisplayUpdateProgress (71, &ProgressBarForegroundColor);
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
MicrocodePatchScratchBuffer = AllocateZeroPool (MicrocodePatchRegionSize);
if (MicrocodePatchScratchBuffer == NULL) {
DEBUG ((DEBUG_ERROR, "Fail to allocate Microcode Scratch buffer\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
return EFI_OUT_OF_RESOURCES;
}
ScratchBufferPtr = MicrocodePatchScratchBuffer;
ScratchBufferSize = 0;
//
// Step 2. Update uCode Major region.
// Before this function, TopSwap region is now a mirror to Major uCode region after syncing with Major uCode,.
// After switching TopSwap bit, MMIO will be routed to TopSwap region and get same content as from Major region
//
DEBUG ((DEBUG_ERROR, "MicrocodeUpdate Phase 1 Start\n"));
//
// Target data collection
//
TargetTotalSize = 0;
AvailableSize = 0;
NextMicrocodeEntryPoint = NULL;
if (TargetMicrocodeEntryPoint != NULL) {
if (TargetMicrocodeEntryPoint->DataSize == 0) {
TargetTotalSize = 2048;
} else {
TargetTotalSize = TargetMicrocodeEntryPoint->TotalSize;
}
DEBUG ((DEBUG_INFO, " TargetTotalSize - 0x%x\n", TargetTotalSize));
NextMicrocodeEntryPoint = GetNextMicrocode(MicrocodeFmpPrivate, TargetMicrocodeEntryPoint);
DEBUG ((DEBUG_INFO, " NextMicrocodeEntryPoint - 0x%x\n", NextMicrocodeEntryPoint));
if (NextMicrocodeEntryPoint != NULL) {
ASSERT ((UINTN)NextMicrocodeEntryPoint >= ((UINTN)TargetMicrocodeEntryPoint + TargetTotalSize));
AvailableSize = (UINTN)NextMicrocodeEntryPoint - (UINTN)TargetMicrocodeEntryPoint;
} else {
AvailableSize = (UINTN)MicrocodePatchAddress + MicrocodePatchRegionSize - (UINTN)TargetMicrocodeEntryPoint;
}
DEBUG ((DEBUG_INFO, " AvailableSize - 0x%x\n", AvailableSize));
ASSERT (AvailableSize >= TargetTotalSize);
}
UsedRegionSize = GetCurrentMicrocodeUsedRegionSize(MicrocodeFmpPrivate);
DEBUG ((DEBUG_INFO, " UsedRegionSize - 0x%x\n", UsedRegionSize));
ASSERT (UsedRegionSize >= TargetTotalSize);
if (TargetMicrocodeEntryPoint != NULL) {
ASSERT ((UINTN)MicrocodePatchAddress + UsedRegionSize >= ((UINTN)TargetMicrocodeEntryPoint + TargetTotalSize));
}
//
// Total Size means the Microcode size.
// Available Size means the Microcode size plus the pad till (1) next Microcode or (2) the end.
//
// (1)
// +------+-----------+-----+------+===================+
// | MCU1 | Microcode | PAD | MCU2 | Empty |
// +------+-----------+-----+------+===================+
// | TotalSize |
// |<-AvailableSize->|
// |<- UsedRegionSize ->|
//
// (2)
// +------+-----------+===================+
// | MCU | Microcode | Empty |
// +------+-----------+===================+
// | TotalSize |
// |<- AvailableSize ->|
// |<-UsedRegionSize->|
//
//
// Update based on policy
//
//
// 1. If there is enough space to update old one in situ, replace old microcode in situ.
//
if (AvailableSize >= ImageSize) {
DEBUG ((DEBUG_INFO, "Replace old microcode in situ\n"));
//
// +------+------------+------+===================+
// |Other | Old Image | ... | Empty |
// +------+------------+------+===================+
//
// +------+---------+--+------+===================+
// |Other |New Image|FF| ... | Empty |
// +------+---------+--+------+===================+
//
// 1.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 1.2. Pad 0xFF
RestSize = AvailableSize - ImageSize;
if (RestSize > 0) {
SetMem (ScratchBufferPtr, RestSize, 0xFF);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode(
(UINTN)TargetMicrocodeEntryPoint,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
goto CONTEXT_CLEAR;
}
//
// 2. If there is enough space to remove old one and add new one, reorg and replace old microcode.
//
if (MicrocodePatchRegionSize - (UsedRegionSize - TargetTotalSize) >= ImageSize) {
if (TargetMicrocodeEntryPoint == NULL) {
DEBUG ((DEBUG_INFO, "Append new microcode\n"));
//
// +------+------------+------+===================+
// |Other1| Other |Other2| Empty |
// +------+------------+------+===================+
//
// +------+------------+------+-----------+=======+
// |Other1| Other |Other2| New Image | Empty |
// +------+------------+------+-----------+=======+
//
Status = UpdateMicrocode(
(UINTN)MicrocodePatchAddress + UsedRegionSize,
Image,
ImageSize,
LastAttemptStatus,
Progress
);
} else {
DEBUG ((DEBUG_INFO, "Reorg and replace old microcode\n"));
//
// +------+------------+------+===================+
// |Other | Old Image | ... | Empty |
// +------+------------+------+===================+
//
// +------+---------------+------+================+
// |Other | New Image | ... | Empty |
// +------+---------------+------+================+
//
// 2.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 2.2. Copy rest images after the old image.
if (NextMicrocodeEntryPoint != 0) {
RestSize = (UINTN)MicrocodePatchAddress + UsedRegionSize - ((UINTN)NextMicrocodeEntryPoint);
CopyMem (ScratchBufferPtr, NextMicrocodeEntryPoint, RestSize);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode(
(UINTN)TargetMicrocodeEntryPoint,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
}
goto CONTEXT_CLEAR;
}
//
// 3. The new image can be put in MCU region, but not all others can be put.
// So all the unused MCU is removed.
//
if (MicrocodePatchRegionSize >= ImageSize) {
//
// +------+------------+------+===================+
// |Other1| Old Image |Other2| Empty |
// +------+------------+------+===================+
//
// +-------------------------------------+--------+
// | New Image | Other |
// +-------------------------------------+--------+
//
DEBUG ((DEBUG_INFO, "Add new microcode from beginning\n"));
MicrocodeCount = MicrocodeFmpPrivate->DescriptorCount;
MicrocodeInfo = MicrocodeFmpPrivate->MicrocodeInfo;
// 3.1. Copy new image
CopyMem (ScratchBufferPtr, Image, ImageSize);
ScratchBufferSize += ImageSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
// 3.2. Copy some others to rest buffer
for (Index = 0; Index < MicrocodeCount; Index++) {
if (!MicrocodeInfo[Index].InUse) {
continue;
}
if (MicrocodeInfo[Index].MicrocodeEntryPoint == TargetMicrocodeEntryPoint) {
continue;
}
if (MicrocodeInfo[Index].TotalSize <= MicrocodePatchRegionSize - ScratchBufferSize) {
CopyMem (ScratchBufferPtr, MicrocodeInfo[Index].MicrocodeEntryPoint, MicrocodeInfo[Index].TotalSize);
ScratchBufferSize += MicrocodeInfo[Index].TotalSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
}
// 3.3. Pad 0xFF
RestSize = MicrocodePatchRegionSize - ScratchBufferSize;
if (RestSize > 0) {
SetMem (ScratchBufferPtr, RestSize, 0xFF);
ScratchBufferSize += RestSize;
ScratchBufferPtr = (UINT8 *)MicrocodePatchScratchBuffer + ScratchBufferSize;
}
Status = UpdateMicrocode(
(UINTN)MicrocodePatchAddress,
MicrocodePatchScratchBuffer,
ScratchBufferSize,
LastAttemptStatus,
Progress
);
goto CONTEXT_CLEAR;
}
//
// 4. The new image size is bigger than the whole MCU region.
// It is an expected failure. Recovery to interrupted update is not supprted
//
DEBUG ((DEBUG_ERROR, "Microcode too big\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
Status = EFI_OUT_OF_RESOURCES;
CONTEXT_CLEAR:
ClearUpdateProgress ();
//FUNC_EXIT:
DEBUG ((DEBUG_ERROR, "MicrocodeUpdate Phase 1 End. Status 0x%x\n", Status));
if (MicrocodePatchScratchBuffer != NULL) {
FreePool(MicrocodePatchScratchBuffer);
}
return Status;
}
/**
Sort FIT microcode entries based upon MicrocodeEntryPoint, from low to high.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
**/
VOID
SortFitMicrocodeInfo (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
FIT_MICROCODE_INFO *FitMicrocodeEntry;
FIT_MICROCODE_INFO *NextFitMicrocodeEntry;
FIT_MICROCODE_INFO TempFitMicrocodeEntry;
FIT_MICROCODE_INFO *FitMicrocodeEntryEnd;
FitMicrocodeEntry = MicrocodeFmpPrivate->FitMicrocodeInfo;
NextFitMicrocodeEntry = FitMicrocodeEntry + 1;
FitMicrocodeEntryEnd = MicrocodeFmpPrivate->FitMicrocodeInfo + MicrocodeFmpPrivate->FitMicrocodeEntryCount;
while (FitMicrocodeEntry < FitMicrocodeEntryEnd) {
while (NextFitMicrocodeEntry < FitMicrocodeEntryEnd) {
if (FitMicrocodeEntry->MicrocodeEntryPoint > NextFitMicrocodeEntry->MicrocodeEntryPoint) {
CopyMem (&TempFitMicrocodeEntry, FitMicrocodeEntry, sizeof (FIT_MICROCODE_INFO));
CopyMem (FitMicrocodeEntry, NextFitMicrocodeEntry, sizeof (FIT_MICROCODE_INFO));
CopyMem (NextFitMicrocodeEntry, &TempFitMicrocodeEntry, sizeof (FIT_MICROCODE_INFO));
}
NextFitMicrocodeEntry = NextFitMicrocodeEntry + 1;
}
FitMicrocodeEntry = FitMicrocodeEntry + 1;
NextFitMicrocodeEntry = FitMicrocodeEntry + 1;
}
}
/**
Write Microcode.
Caution: This function may receive untrusted input.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptVersion The last attempt version, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] AbortReason A pointer to a pointer to a null-terminated string providing more
details for the aborted operation. The buffer is allocated by this function
with AllocatePool(), and it is the caller's responsibility to free it with a
call to FreePool().
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_VOLUME_CORRUPTED The Microcode image is corrupted.
@retval EFI_INCOMPATIBLE_VERSION The Microcode image version is incorrect.
@retval EFI_SECURITY_VIOLATION The Microcode image fails to load.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
EFIAPI
MicrocodeSlotSpiWrite (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN VOID *Image,
IN UINTN ImageSize,
IN VOID *NewVersion, OPTIONAL
IN UINTN NewVersionSize, OPTIONAL
OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus,
OUT CHAR16 **AbortReason,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
EFI_STATUS Status;
VOID *AlignedImage;
CPU_MICROCODE_HEADER *TargetMicrocodeEntryPoint;
UINTN TargetMicrcodeIndex;
UINTN Index;
UINTN TargetCpuIndex;
UINTN CpuIndex;
PROCESSOR_INFO *ProcessorInfo;
UINTN *TargetProcessorBuf;
UINTN TargetProcessorNum;
MICROCODE_INFO *MicrocodeInfo;
AlignedImage = Image;
TargetMicrocodeEntryPoint = NULL;
ProcessorInfo = MicrocodeFmpPrivate->ProcessorInfo;
TargetMicrcodeIndex = (UINTN) - 1;
//
// MCU must be 16 bytes aligned
//
SetUpdateProgress (UpdatinguCode, 61);
Progress(61);
AlignedImage = AllocateCopyPool(ImageSize, Image); //only one microcode
if (AlignedImage == NULL) {
DEBUG ((DEBUG_ERROR, "Fail to allocate aligned image\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
return EFI_OUT_OF_RESOURCES;
}
TargetProcessorBuf = AllocateZeroPool(sizeof(UINTN) * MicrocodeFmpPrivate->ProcessorCount);
if (TargetProcessorBuf == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto FUNC_EXIT;
}
DEBUG ((DEBUG_INFO, "Start to verify new uCode!\n"));
//
// Check all physical/logic CPUs that new uCode can apply to
//
for (CpuIndex = 0, TargetProcessorNum = 0; CpuIndex < MicrocodeFmpPrivate->ProcessorCount; CpuIndex++) {
Status = VerifyMicrocode(
MicrocodeFmpPrivate,
AlignedImage,
ImageSize,
FALSE,
LastAttemptStatus,
AbortReason,
&CpuIndex
);
//
// Update must make sure new uCode can apply to CPU and version is higher than existing one.
//
if (Status == EFI_SUCCESS) {
MicrocodeInfo = &MicrocodeFmpPrivate->MicrocodeInfo[ProcessorInfo[CpuIndex].MicrocodeIndex];
DEBUG ((DEBUG_INFO, " New uCode Target CpuIndex found- 0x%x\n", CpuIndex));
DEBUG ((DEBUG_INFO, " New uCod Version 0x%x\n", ((CPU_MICROCODE_HEADER *)AlignedImage)->UpdateRevision));
DEBUG ((DEBUG_INFO, " Existing uCode Revision 0x%x\n", MicrocodeInfo->MicrocodeEntryPoint->UpdateRevision));
if ((ProcessorInfo[CpuIndex].MicrocodeIndex == (UINT32) -1 ||
((CPU_MICROCODE_HEADER *)AlignedImage)->UpdateRevision > MicrocodeInfo->MicrocodeEntryPoint->UpdateRevision)) {
TargetProcessorBuf[TargetProcessorNum] = CpuIndex;
TargetProcessorNum++;
}
}
}
if (TargetProcessorNum == 0) {
//
// New uCode is not in the uCode selection policy list. Ignore this uCode
//
DEBUG ((DEBUG_ERROR, "New uCode fails in verification! Quit Update.\n"));
Status = EFI_INVALID_PARAMETER;
goto FUNC_EXIT;
}
//
// Find a replacable uCode existing on flash. It has a smaller or equivalent CPU support set comparing with new uCode
// regarding platform supported CPU set.
//
for (Index = 0; Index < TargetProcessorNum; Index++) {
TargetCpuIndex = TargetProcessorBuf[Index];
//
// New uCode targeting CPU don't have an exisiting uCode to replace. Skip it
//
if (ProcessorInfo[TargetCpuIndex].MicrocodeIndex == (UINTN) -1) {
continue;
}
for (CpuIndex = 0; CpuIndex < MicrocodeFmpPrivate->ProcessorCount; CpuIndex++) {
//
// Only check Processor beyond new uCode support list
//
if (IsCpuInTargetCpuList(CpuIndex, TargetProcessorBuf, TargetProcessorNum)) {
continue;
}
//
// If existing uCode is supporting a larger Processor list than new uCode , it can't be replcaed
//
if (ProcessorInfo[CpuIndex].MicrocodeIndex == ProcessorInfo[TargetCpuIndex].MicrocodeIndex) {
break;
}
}
//
// Found an exisintg uCode that support no more processors beyond new uCode. It is replacable candidate
//
if (CpuIndex == MicrocodeFmpPrivate->ProcessorCount) {
TargetMicrcodeIndex = MicrocodeFmpPrivate->ProcessorInfo[TargetCpuIndex].MicrocodeIndex;
break;
}
}
DEBUG ((DEBUG_INFO, " TargetMicrocodeIndex - 0x%x\n", TargetMicrcodeIndex));
if (TargetMicrcodeIndex != (UINTN)-1) {
ASSERT (TargetMicrcodeIndex < MicrocodeFmpPrivate->DescriptorCount);
TargetMicrocodeEntryPoint = MicrocodeFmpPrivate->MicrocodeInfo[TargetMicrcodeIndex].MicrocodeEntryPoint;
} else {
TargetMicrocodeEntryPoint = NULL;
}
DEBUG ((DEBUG_INFO, " TargetMicrocodeEntryPoint - 0x%x\n", TargetMicrocodeEntryPoint));
DEBUG ((DEBUG_INFO, " Try to update, Fit mode or Non-fit mode!\n"));
//
// Record uCode update progress. Used for Seamless recovery from interrupted update
//
if (MicrocodeFmpPrivate->FitMicrocodeInfo != NULL) {
Status = UpdateMicrocodeFlashRegionWithFit (
MicrocodeFmpPrivate,
TargetMicrocodeEntryPoint,
AlignedImage,
ImageSize,
NewVersion,
NewVersionSize,
LastAttemptStatus,
Progress
);
} else {
Status = UpdateMicrocodeFlashRegion (
MicrocodeFmpPrivate,
TargetMicrocodeEntryPoint,
AlignedImage,
ImageSize,
LastAttemptStatus,
Progress
);
}
*LastAttemptVersion = ((INTEL_MICROCODE_VERSION_FFS_DATA *)NewVersion)->Version;
FUNC_EXIT:
FreePool(AlignedImage);
if (TargetProcessorBuf!= NULL) {
FreePool(TargetProcessorBuf);
}
return Status;
}
/**
Write Microcode.
Caution: This function may receive untrusted input.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptVersion The last attempt version, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] AbortReason A pointer to a pointer to a null-terminated string providing more
details for the aborted operation. The buffer is allocated by this function
with AllocatePool(), and it is the caller's responsibility to free it with a
call to FreePool().
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_VOLUME_CORRUPTED The Microcode image is corrupted.
@retval EFI_INCOMPATIBLE_VERSION The Microcode image version is incorrect.
@retval EFI_SECURITY_VIOLATION The Microcode image fails to load.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
EFIAPI
MicrocodeSpiWrite (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN VOID *Image,
IN UINTN ImageSize,
OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus,
OUT CHAR16 **AbortReason,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
EFI_STATUS Status;
VOID *AlignedImage;
AlignedImage = Image;
if (ImageSize > PcdGet32(PcdFlashNvStorageMicrocodeSize)) {
return EFI_INVALID_PARAMETER;
}
//
// MCU must be 16 bytes aligned
//
AlignedImage = AllocateCopyPool(ImageSize, Image);
if (AlignedImage == NULL) {
DEBUG ((DEBUG_ERROR, "Fail to allocate aligned image\n"));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
return EFI_OUT_OF_RESOURCES;
}
DEBUG ((DEBUG_INFO, "Update uCode region - Start\n"));
Status = UpdateMicrocode(
FixedPcdGet32 (PcdFlashNvStorageMicrocodeBase), // 0xFFC50000
AlignedImage,
ImageSize,
LastAttemptStatus,
Progress
);
DEBUG ((DEBUG_INFO, "Update uCode region - Done\n"));
//FUNC_EXIT:
FreePool(AlignedImage);
return Status;
}
/*
_________
| |
| Bgup |
|_______|
| |
| Data |
|_______|
| |
| Cert |
|_______|
*/
EFI_STATUS
GetBiosGuardData (
IN VOID *FullFirmwareImage,
IN UINTN FullFirmwareImageSize,
IN BIOS_GUARD_DATA *InputBuffer,
IN UINTN IndexOfBlock
) {
UINT8 *UcodeDataPtr;
UINT32 UcodeDataSize;
INSYDE_BIOSGUARD_HEADER *BgupHeaderPtr;
UINT8 *BgupDataPtr;
INSYDE_CERT_HEADER *CertHeaderPtr;
UINT8 *CertDataPtr;
H2O_CAPSULE_HEADER *H2oCapsuleHeader;
H2O_CAPSULE_HEADER *H2oCertHeader;
H2O_CAPSULE_HEADER *H2oBgupHeader;
BOOLEAN IsAlign64K;
EFI_CAPSULE_HEADER *Datatbuffer;
UINT8 *Ptr;
UINTN Index;
BOOLEAN IsFound;
UcodeDataPtr = NULL;
UcodeDataSize = 0;
BgupHeaderPtr = NULL;
BgupDataPtr = NULL;
CertHeaderPtr = NULL;
CertDataPtr = NULL;
H2oCapsuleHeader = NULL;
H2oCertHeader = NULL;
H2oBgupHeader = NULL;
IsAlign64K = FALSE;
IsFound = FALSE;
Datatbuffer = ((EFI_CAPSULE_HEADER*)FullFirmwareImage);
if (CompareGuid(&Datatbuffer->CapsuleGuid, PcdGetPtr (PcdWindowsUcodeFirmwareCapsuleGuid))) {
for (Index = 0; Index < Datatbuffer->CapsuleImageSize; Index++) {
Ptr = (UINT8 *)Datatbuffer + Datatbuffer->HeaderSize + Index;
if (CompareMem (Ptr, InsydeUcodeSig, sizeof (InsydeUcodeSig)) == 0) {
H2oCapsuleHeader = (H2O_CAPSULE_HEADER *) Ptr;
IsFound = TRUE;
break;
}
}
}
if (IsFound) {
UcodeDataPtr = (UINT8*)H2oCapsuleHeader + sizeof(H2O_CAPSULE_HEADER);
UcodeDataSize = H2oCapsuleHeader->RealSize;
} else {
return EFI_UNSUPPORTED;
}
//
// Get ucode data (FullMode)
//
if (UcodeDataSize % SIZE_64KB == 0) {
IsAlign64K = TRUE;
}
if (!IsAlign64K && (IndexOfBlock+1 == UcodeDataSize/SIZE_64KB)) {
InputBuffer->InputSize = UcodeDataSize - ((IndexOfBlock + 1)*SIZE_64KB);
InputBuffer->InputData = (VOID*)(UcodeDataPtr + IndexOfBlock*InputBuffer->InputSize);
} else {
InputBuffer->InputSize = SIZE_64KB;
InputBuffer->InputData = (VOID*)(UcodeDataPtr + IndexOfBlock*SIZE_64KB);
}
//
// Get Certificate header
//
H2oCertHeader = (H2O_CAPSULE_HEADER*)((UINT8*)UcodeDataPtr + H2oCapsuleHeader->AllocateSize);
if (CompareMem(H2oCertHeader->HeaderSignature , InsydeCertHeaderSig, sizeof(InsydeCertHeaderSig)) == 0) {
CertHeaderPtr = (INSYDE_CERT_HEADER*)((UINT8*)H2oCertHeader + sizeof(H2O_CAPSULE_HEADER));
} else {
return EFI_UNSUPPORTED;
}
CertDataPtr = ((UINT8*)CertHeaderPtr + sizeof(INSYDE_CERT_HEADER)); //$PFATCER
InputBuffer->Cert = CertDataPtr + IndexOfBlock*CertHeaderPtr->BlockSize;
InputBuffer->CertSize = CertHeaderPtr->BlockSize;
//
// Get Bgup header
//
H2oBgupHeader = (H2O_CAPSULE_HEADER*)((UINT8*)CertHeaderPtr + H2oCertHeader->AllocateSize);
if (CompareMem(H2oBgupHeader->HeaderSignature , InsydeBgupHeaderSig, sizeof(InsydeBgupHeaderSig)) == 0) {
BgupHeaderPtr = (INSYDE_BIOSGUARD_HEADER*)((UINT8*)H2oBgupHeader + sizeof(H2O_CAPSULE_HEADER));
} else {
return EFI_UNSUPPORTED;
}
BgupDataPtr = ((UINT8*)BgupHeaderPtr + BgupHeaderPtr->StructureSize); //$PFATHDR
InputBuffer->Bgup = BgupDataPtr + IndexOfBlock*BgupHeaderPtr->BlockSize;
InputBuffer->BgupSize = BgupHeaderPtr->BlockSize;
return EFI_SUCCESS;
}
/**
Update uCode via BiosGuard service.
@param[in] SystemFirmwareImage Points to the System Firmware (BIOS) image.
@param[in] SystemFirmwareImageSize The length of the System Firmware image in bytes.
@param[out] BgupImage Points to BgupImage which would be sent to BiosGaurd ACM along with SystemFirmwareImage.
BgupImage contains BGSL to update BIOS and certificate for authentication.
@param[out] BgupImageSize The length of the BgupImage in bytes.
@retval EFI_SUCCESS The System Firmware image is updated successfully.
@retval EFI_SECURITY_VIOLATION The update operation fails due to SVN check error.
@retval EFI_DEVICE_ERROR The update operation fails.
@retval EFI_INVALID_PARAMETER BgupImage is NULL or BgupImageSize is unexpected.
@retval Others The update operation fails.
**/
EFI_STATUS
PerformBiosGuardUpdateuCode (
IN VOID *SystemFirmwareImage,
IN UINTN SystemFirmwareImageSize,
IN BIOS_GUARD_DATA *InputBuffer
)
{
EFI_STATUS Status;
BIOSGUARD_HOB *BiosGuardHobPtr;
EFI_PHYSICAL_ADDRESS BiosGuardMemAddress;
UINT32 BiosGuardMemSize;
EFI_PHYSICAL_ADDRESS BgupCertificate;
EFI_PHYSICAL_ADDRESS BgIoTrapAddress;
UINT8 *BiosGuardMemAddressPtr;
UINT8 *BgupCertificatePtr;
UINT64 BiosGuardStatus;
ASSERT (SystemFirmwareImage != NULL);
ASSERT (SystemFirmwareImageSize != 0);
ASSERT (InputBuffer != NULL);
BiosGuardHobPtr = NULL;
BiosGuardMemAddressPtr = NULL;
BgupCertificatePtr = NULL;
BiosGuardMemAddress = 0;
BiosGuardMemSize = 0;
BgIoTrapAddress = 0;
Status = EFI_NOT_STARTED;
//
// Get BIOS Guard Hob
//
BiosGuardHobPtr = GetFirstGuidHob (&gBiosGuardHobGuid);
if (BiosGuardHobPtr == NULL) {
DEBUG ((DEBUG_ERROR, "BIOS Guard HOB not available\n"));
return EFI_DEVICE_ERROR;
}
BiosGuardMemAddress = (EFI_PHYSICAL_ADDRESS) BiosGuardHobPtr->BiosGuardMemAddress;
BiosGuardMemSize = (UINT32) LShiftU64 (BiosGuardHobPtr->BiosGuardMemSize, 20);
BgIoTrapAddress = (EFI_PHYSICAL_ADDRESS) BiosGuardHobPtr->BiosGuardIoTrapAddress;
BgupCertificate = (EFI_PHYSICAL_ADDRESS) (BiosGuardMemAddress + BiosGuardMemSize - BGUPC_MEMORY_OFFSET);
BiosGuardMemAddressPtr = (UINT8 *) BiosGuardMemAddress;
BgupCertificatePtr = (UINT8 *) BgupCertificate;
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdate: BiosGuardMemAddress = %x\n", BiosGuardMemAddress));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdate: BiosGuardMemSize = %x\n", BiosGuardMemSize));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdate: BgupCertificate = %x\n", BgupCertificate));
CopyMem (BiosGuardMemAddressPtr, InputBuffer->Bgup, InputBuffer->BgupSize); //bgup (bgup header (0x30)+ script (0xa0) == INSYDE_BIOSGUARD_HEADER.BlockSize)
CopyMem ((BiosGuardMemAddressPtr + InputBuffer->BgupSize), InputBuffer->InputData , InputBuffer->InputSize); //data (64k)
CopyMem (BgupCertificatePtr, InputBuffer->Cert, InputBuffer->CertSize); // cerificate , size = sizeof (BGUPC_ALGORITHM_1);
IoRead8 (BgIoTrapAddress);
CopyMem (&BiosGuardStatus, BiosGuardMemAddressPtr, sizeof (UINT64));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdate: BIOS GUARD Bios Update Execution Result = 0x%016llX\n", BiosGuardStatus));
if ((BiosGuardStatus & 0xFFFF) != 0) {
switch (BiosGuardStatus) {
case ERR_BAD_SVN:
Status = EFI_SECURITY_VIOLATION;
break;
default:
Status = EFI_DEVICE_ERROR;
break;
}
} else if ((BiosGuardStatus & 0xFFFF0000) != 0) {
//
// BGUP execution succeds but function exits with extra error code
// 1 Erase error
// 2 Write error
// 3 Region error
//
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdate: extra data returns BIOS GUARD script If = %x\n", (BiosGuardStatus & 0xFFFF0000) >> 16));
Status = EFI_DEVICE_ERROR;
} else {
Status = EFI_SUCCESS;
}
return Status;
}
/**
Write Microcode.
Caution: This function may receive untrusted input.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptVersion The last attempt version, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] AbortReason A pointer to a pointer to a null-terminated string providing more
details for the aborted operation. The buffer is allocated by this function
with AllocatePool(), and it is the caller's responsibility to free it with a
call to FreePool().
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_VOLUME_CORRUPTED The Microcode image is corrupted.
@retval EFI_INCOMPATIBLE_VERSION The Microcode image version is incorrect.
@retval EFI_SECURITY_VIOLATION The Microcode image fails to load.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
EFIAPI
MicrocodeBiosGuardWrite (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN VOID *Image,
IN UINTN ImageSize,
OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus,
OUT CHAR16 **AbortReason,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
EFI_STATUS Status;
UINTN Index;
BIOS_GUARD_DATA *InputData;
UINT32 Count;
if (PcdGet32(PcdFlashNvStorageMicrocodeSize)%SIZE_64KB == 0) {
Count = PcdGet32(PcdFlashNvStorageMicrocodeSize)/SIZE_64KB;
} else {
Count = PcdGet32(PcdFlashNvStorageMicrocodeSize)/SIZE_64KB + 1;
}
InputData = AllocateZeroPool(sizeof(BIOS_GUARD_DATA));
for (Index = 0; Index < Count ; Index++){
Status = GetBiosGuardData(Image, ImageSize, InputData, Index);
if (!EFI_ERROR(Status)) {
SetUpdateProgress (UpdatinguCode, 55 + 6*(UINT32)Index);
Progress(55 + 6*(UINT32)Index);
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdateuCode Index=%x\n",Index));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdateuCode InputData->InputData=%x, InputData->InputSize=%x\n",InputData->InputData,InputData->InputSize));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdateuCode InputData->Bgup=%x, InputData->BgupSize=%x\n",InputData->Bgup, InputData->BgupSize));
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdateuCode InputData->Cert=%x, InputData->CertSize=%x\n",InputData->Cert, InputData->CertSize));
Status = PerformBiosGuardUpdateuCode(Image, ImageSize, InputData);
if(EFI_ERROR(Status)) {
DEBUG ((DEBUG_INFO, "PerformBiosGuardUpdateuCode Error, Status = %r\n", Status));
break;
}
}
}
FreePool(InputData);
return Status;
}
/**
Write Microcode.
Caution: This function may receive untrusted input.
@param[in] MicrocodeFmpPrivate The Microcode driver private data
@param[in] Image The Microcode image buffer.
@param[in] ImageSize The size of Microcode image buffer in bytes.
@param[out] LastAttemptVersion The last attempt version, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] LastAttemptStatus The last attempt status, which will be recorded in ESRT and FMP EFI_FIRMWARE_IMAGE_DESCRIPTOR.
@param[out] AbortReason A pointer to a pointer to a null-terminated string providing more
details for the aborted operation. The buffer is allocated by this function
with AllocatePool(), and it is the caller's responsibility to free it with a
call to FreePool().
@retval EFI_SUCCESS The Microcode image is written.
@retval EFI_VOLUME_CORRUPTED The Microcode image is corrupted.
@retval EFI_INCOMPATIBLE_VERSION The Microcode image version is incorrect.
@retval EFI_SECURITY_VIOLATION The Microcode image fails to load.
@retval EFI_WRITE_PROTECTED The flash device is read only.
**/
EFI_STATUS
EFIAPI
MicrocodeWrite (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate,
IN VOID *Image,
IN UINTN ImageSize,
OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus,
OUT CHAR16 **AbortReason,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
)
{
EFI_STATUS Status;
UCODE_PAYLOAD_ENTRY *Entry;
UINTN EntryCount;
UINT8 *AlignedImage;
H2O_CAPSULE_HEADER *CapsuleHeader;
VOID *CapsulePtr;
UINTN CapsuleSize;
Entry = NULL;
AlignedImage = NULL;
CapsulePtr = NULL;
CapsuleSize = 0;
DEBUG ((DEBUG_INFO, "[%a] Enter!\n", __FUNCTION__));
CapsuleHeader = AllocatePool(sizeof (H2O_CAPSULE_HEADER));
Status = GetUcodeCapsuleInfo (Image, &CapsuleHeader);
if (EFI_ERROR (Status)) {
return Status;
}
CapsulePtr = (VOID *)((UINT8*)CapsuleHeader + sizeof(H2O_CAPSULE_HEADER));
CapsuleSize = CapsuleHeader->RealSize;
//
// XDR RFC requres the Fixed-Length Array starting address to be UINT32 aligned
// Aligned buffer will be used later on
//
if (PcdGetBool(PcdBiosGuardEnable) == FALSE) {
if (((UINTN)CapsulePtr % sizeof(UINT32)) != 0) {
AlignedImage = AllocateCopyPool (CapsuleSize, CapsulePtr);
if (AlignedImage == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
CapsulePtr = AlignedImage;
}
//
// Extra All infomation from uCode Capsule payload. It is encoded
//
Status = ExtractuCodeCapsuleXdrData((VOID*)CapsulePtr, CapsuleSize, &Entry, &EntryCount);
if (EFI_ERROR(Status)) {
return Status;
}
DEBUG ((DEBUG_INFO, "[%a] Extract XDR header from payload!\n", __FUNCTION__));
}
//
// There are 3 update modes. Update policies are different
// 1) BiosGuard enable, only support full uCode range update. Do not consider
// 2) BiosGuard disable, full uCode range SPI update
// 3) BiosGuard disable, flexible uCode slot update controlled by uCode Selection PCD
//
SetUpdateProgress (UpdatinguCode, 51);
Progress(51);
if (PcdGetBool(PcdBiosGuardEnable)) {
SetUpdateProgress (UpdatinguCode, 55);
Progress(55);
TopSwapControl (TRUE);
DEBUG ((DEBUG_INFO, "Microcode full range update (BiosGuard Enable)\n"));
Status = MicrocodeBiosGuardWrite (
MicrocodeFmpPrivate,
Image,
ImageSize,
LastAttemptVersion,
LastAttemptStatus,
AbortReason,
Progress
);
TopSwapControl (FALSE);
} else if (Entry[uCodeFullRangeIndex].EntrySize > 0) {
SetUpdateProgress (UpdatinguCode, 55);
Progress(55);
TopSwapControl (TRUE);
DEBUG ((DEBUG_INFO, "Microcode full range update (BiosGuard Disable)\n"));
Status = MicrocodeSpiWrite(
MicrocodeFmpPrivate,
Entry[uCodeFullRangeIndex].EntryPtr,
Entry[uCodeFullRangeIndex].EntrySize,
LastAttemptVersion,
LastAttemptStatus,
AbortReason,
Progress
);
TopSwapControl (FALSE);
} else if (EntryCount == uCodeArrayMax && Entry[uCodeFullRangeIndex].EntrySize == 0 && Entry[uCodeArrayIndex].EntrySize > 0) {
TopSwapControl (TRUE);
DEBUG ((DEBUG_INFO, "Microcode slot update mode (BiosGuard Disabled)\n"));
Status = MicrocodeSlotSpiWrite(
MicrocodeFmpPrivate,
Entry[uCodeArrayIndex].EntryPtr,
Entry[uCodeArrayIndex].EntrySize,
Entry[uCodeVersionIndex].EntryPtr,
Entry[uCodeVersionIndex].EntrySize,
LastAttemptVersion,
LastAttemptStatus,
AbortReason,
Progress
);
TopSwapControl (FALSE);
} else {
ASSERT(FALSE);
Status = EFI_INVALID_PARAMETER;
DEBUG ((DEBUG_INFO, "[%a] Invalid capsule type!", __FUNCTION__));
}
SetUpdateProgress (UpdatinguCode, 90);
Progress(90);
DEBUG ((DEBUG_INFO, "Microcode update status 0x%x\n", Status));
EXIT:
if (Entry != NULL) {
FreePool(Entry);
}
if (AlignedImage != NULL) {
FreePool(AlignedImage);
}
ClearUpdateProgress ();
return Status;
}
/**
Initialize FIT microcode information.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
@return EFI_SUCCESS FIT microcode information is initialized.
@return EFI_OUT_OF_RESOURCES No enough resource for the initialization.
@return EFI_DEVICE_ERROR There is something wrong in FIT microcode entry.
**/
EFI_STATUS
InitializeFitMicrocodeInfo (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
UINT64 FitPointer;
FIRMWARE_INTERFACE_TABLE_ENTRY *FitEntry;
UINT32 EntryNum;
UINT32 MicrocodeEntryNum;
UINT32 Index;
UINTN Address;
VOID *MicrocodePatchAddress;
UINTN MicrocodePatchRegionSize;
FIT_MICROCODE_INFO *FitMicrocodeInfo;
FIT_MICROCODE_INFO *FitMicrocodeInfoNext;
CPU_MICROCODE_HEADER *MicrocodeEntryPoint;
CPU_MICROCODE_HEADER *MicrocodeEntryPointNext;
UINTN FitMicrocodeIndex;
MICROCODE_INFO *MicrocodeInfo;
UINTN MicrocodeIndex;
if (MicrocodeFmpPrivate->FitMicrocodeInfo != NULL) {
FreePool (MicrocodeFmpPrivate->FitMicrocodeInfo);
MicrocodeFmpPrivate->FitMicrocodeInfo = NULL;
MicrocodeFmpPrivate->FitMicrocodeEntryCount = 0;
}
FitPointer = *(UINT64 *) (UINTN) FIT_POINTER_ADDRESS;
if ((FitPointer == 0) ||
(FitPointer == 0xFFFFFFFFFFFFFFFF) ||
(FitPointer == 0xEEEEEEEEEEEEEEEE)) {
//
// No FIT table.
//
return EFI_SUCCESS;
}
FitEntry = (FIRMWARE_INTERFACE_TABLE_ENTRY *) (UINTN) FitPointer;
if ((FitEntry[0].Type != FIT_TYPE_00_HEADER) ||
(FitEntry[0].Address != FIT_TYPE_00_SIGNATURE)) {
//
// Invalid FIT table, treat it as no FIT table.
//
return EFI_SUCCESS;
}
EntryNum = *(UINT32 *)(&FitEntry[0].Size[0]) & 0xFFFFFF;
//
// Calculate microcode entry number.
//
MicrocodeEntryNum = 0;
for (Index = 0; Index < EntryNum; Index++) {
if (FitEntry[Index].Type == FIT_TYPE_01_MICROCODE) {
MicrocodeEntryNum++;
}
}
if (MicrocodeEntryNum == 0) {
//
// No FIT microcode entry.
//
return EFI_SUCCESS;
}
//
// Allocate buffer.
//
MicrocodeFmpPrivate->FitMicrocodeInfo = AllocateZeroPool (MicrocodeEntryNum * sizeof (FIT_MICROCODE_INFO));
if (MicrocodeFmpPrivate->FitMicrocodeInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
MicrocodeFmpPrivate->FitMicrocodeEntryCount = MicrocodeEntryNum;
MicrocodePatchAddress = MicrocodeFmpPrivate->MicrocodePatchAddress;
MicrocodePatchRegionSize = MicrocodeFmpPrivate->MicrocodePatchRegionSize;
//
// Collect microcode entry info.
//
MicrocodeEntryNum = 0;
for (Index = 0; Index < EntryNum; Index++) {
if (FitEntry[Index].Type == FIT_TYPE_01_MICROCODE) {
Address = (UINTN) FitEntry[Index].Address;
if ((Address < (UINTN) MicrocodePatchAddress) ||
(Address >= ((UINTN) MicrocodePatchAddress + MicrocodePatchRegionSize))) {
DEBUG ((
DEBUG_ERROR,
"InitializeFitMicrocodeInfo - Address (0x%x) is not in Microcode Region\n",
Address
));
goto ErrorExit;
}
FitMicrocodeInfo = &MicrocodeFmpPrivate->FitMicrocodeInfo[MicrocodeEntryNum];
FitMicrocodeInfo->MicrocodeEntryPoint = (CPU_MICROCODE_HEADER *) Address;
if ((*(UINT32 *) Address) == 0xFFFFFFFF) {
//
// It is the empty slot as long as the first dword is 0xFFFF_FFFF.
//
FitMicrocodeInfo->Empty = TRUE;
} else {
FitMicrocodeInfo->Empty = FALSE;
}
MicrocodeEntryNum++;
}
}
//
// Every microcode should have a FIT microcode entry.
//
for (MicrocodeIndex = 0; MicrocodeIndex < MicrocodeFmpPrivate->DescriptorCount; MicrocodeIndex++) {
MicrocodeInfo = &MicrocodeFmpPrivate->MicrocodeInfo[MicrocodeIndex];
for (FitMicrocodeIndex = 0; FitMicrocodeIndex < MicrocodeFmpPrivate->FitMicrocodeEntryCount; FitMicrocodeIndex++) {
FitMicrocodeInfo = &MicrocodeFmpPrivate->FitMicrocodeInfo[FitMicrocodeIndex];
if (MicrocodeInfo->MicrocodeEntryPoint == FitMicrocodeInfo->MicrocodeEntryPoint) {
FitMicrocodeInfo->InUse = MicrocodeInfo->InUse;
break;
}
}
if (FitMicrocodeIndex >= MicrocodeFmpPrivate->FitMicrocodeEntryCount) {
DEBUG ((
DEBUG_ERROR,
"InitializeFitMicrocodeInfo - There is no FIT microcode entry for Microcode (0x%x). It could be caused by incorrect uCode\n",
MicrocodeInfo->MicrocodeEntryPoint
));
ASSERT(FALSE);
goto ErrorExit;
}
}
SortFitMicrocodeInfo (MicrocodeFmpPrivate);
//
// Check overlap.
//
for (FitMicrocodeIndex = 0; FitMicrocodeIndex < MicrocodeFmpPrivate->FitMicrocodeEntryCount - 1; FitMicrocodeIndex++) {
FitMicrocodeInfo = &MicrocodeFmpPrivate->FitMicrocodeInfo[FitMicrocodeIndex];
MicrocodeEntryPoint = FitMicrocodeInfo->MicrocodeEntryPoint;
FitMicrocodeInfoNext = &MicrocodeFmpPrivate->FitMicrocodeInfo[FitMicrocodeIndex + 1];
MicrocodeEntryPointNext = FitMicrocodeInfoNext->MicrocodeEntryPoint;
if ((MicrocodeEntryPoint >= MicrocodeEntryPointNext) ||
((FitMicrocodeInfo->TotalSize != 0) &&
((UINTN) MicrocodeEntryPoint + FitMicrocodeInfo->TotalSize) >
(UINTN) MicrocodeEntryPointNext)) {
DEBUG ((
DEBUG_ERROR,
"InitializeFitMicrocodeInfo - There is overlap between FIT microcode entries (0x%x 0x%x)\n",
MicrocodeEntryPoint,
MicrocodeEntryPointNext
));
goto ErrorExit;
}
FitMicrocodeInfo->TotalSize = (UINTN)MicrocodeEntryPointNext - (UINTN)MicrocodeEntryPoint;
}
//
// Handle last Fit entry totalsize
//
FitMicrocodeInfo = &MicrocodeFmpPrivate->FitMicrocodeInfo[FitMicrocodeIndex];
FitMicrocodeInfo->TotalSize = (UINTN)MicrocodeFmpPrivate->MicrocodePatchAddress + MicrocodeFmpPrivate->MicrocodePatchRegionSize - (UINTN)FitMicrocodeInfo->MicrocodeEntryPoint;
DEBUG_CODE(
for (FitMicrocodeIndex = 0; FitMicrocodeIndex < MicrocodeFmpPrivate->FitMicrocodeEntryCount; FitMicrocodeIndex++) {
FitMicrocodeInfo = &MicrocodeFmpPrivate->FitMicrocodeInfo[FitMicrocodeIndex];
MicrocodeEntryPoint = FitMicrocodeInfo->MicrocodeEntryPoint;
DEBUG ((
DEBUG_ERROR,
"InitializeFitMicrocodeInfo - FIT microcode entries [0x%x 0x%x)\n",
MicrocodeEntryPoint,
(UINT8 *)MicrocodeEntryPoint + FitMicrocodeInfo->TotalSize
));
}
);
return EFI_SUCCESS;
ErrorExit:
FreePool (MicrocodeFmpPrivate->FitMicrocodeInfo);
MicrocodeFmpPrivate->FitMicrocodeEntryCount = 0;
MicrocodeFmpPrivate->FitMicrocodeInfo = NULL;
return EFI_DEVICE_ERROR;
}
/**
Initialize Processor Microcode Index.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
**/
VOID
InitializedProcessorMicrocodeIndex (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
UINTN CpuIndex;
UINTN MicrocodeIndex;
UINT32 AttemptStatus;
EFI_STATUS Status;
MICROCODE_INFO *MicrocodeInfo;
PROCESSOR_INFO *ProcessorInfo;
for (CpuIndex = 0; CpuIndex < MicrocodeFmpPrivate->ProcessorCount; CpuIndex++) {
ProcessorInfo = &MicrocodeFmpPrivate->ProcessorInfo[CpuIndex];
if (ProcessorInfo->MicrocodeIndex != (UINTN)-1) {
continue;
}
for (MicrocodeIndex = 0; MicrocodeIndex < MicrocodeFmpPrivate->DescriptorCount; MicrocodeIndex++) {
MicrocodeInfo = &MicrocodeFmpPrivate->MicrocodeInfo[MicrocodeIndex];
if (!MicrocodeInfo->InUse) {
continue;
}
Status = VerifyMicrocode(
MicrocodeFmpPrivate,
MicrocodeInfo->MicrocodeEntryPoint, //FvMicrocodePatch 0X85000+0x1000 //0xffc51000
MicrocodeInfo->TotalSize, //FvMicrocodeSize - 0x1000 //0x1bc000
FALSE,
&AttemptStatus,
NULL,
&CpuIndex
);
DEBUG ((DEBUG_INFO, "InitializedProcessorMicrocodeIndex Microcode %x verify status %x, CPU Index %x\n", MicrocodeIndex, Status, CpuIndex));
if (!EFI_ERROR(Status)) {
ProcessorInfo->MicrocodeIndex = MicrocodeIndex;
//
// Update logic CPU Microcode Revision with highest uCode revision on flash. As MircocodeVersion can't be read from logic CPU defined by uCode Selection Policy PCD
// This logic complies with Physical CPU uCode patching logic
//
if (!ProcessorInfo->IsRealCpu) {
if ((ProcessorInfo->MicrocodeRevision == (UINT32) -1) ||
(ProcessorInfo->MicrocodeRevision < MicrocodeInfo->MicrocodeEntryPoint->UpdateRevision)) {
ProcessorInfo->MicrocodeRevision = MicrocodeInfo->MicrocodeEntryPoint->UpdateRevision;
}
}
}
}
}
}
/**
Initialize Microcode Descriptor.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
@return EFI_SUCCESS Microcode Descriptor is initialized.
@return EFI_OUT_OF_RESOURCES No enough resource for the initialization.
**/
EFI_STATUS
InitializeMicrocodeDescriptor (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
EFI_STATUS Status;
UINT8 CurrentMicrocodeCount;
CurrentMicrocodeCount = (UINT8)GetMicrocodeInfo (MicrocodeFmpPrivate, 0, NULL, NULL);
if (CurrentMicrocodeCount > MicrocodeFmpPrivate->DescriptorCount) {
if (MicrocodeFmpPrivate->ImageDescriptor != NULL) {
FreePool(MicrocodeFmpPrivate->ImageDescriptor);
MicrocodeFmpPrivate->ImageDescriptor = NULL;
}
if (MicrocodeFmpPrivate->MicrocodeInfo != NULL) {
FreePool(MicrocodeFmpPrivate->MicrocodeInfo);
MicrocodeFmpPrivate->MicrocodeInfo = NULL;
}
} else {
ZeroMem(MicrocodeFmpPrivate->ImageDescriptor, MicrocodeFmpPrivate->DescriptorCount * sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR));
ZeroMem(MicrocodeFmpPrivate->MicrocodeInfo, MicrocodeFmpPrivate->DescriptorCount * sizeof(MICROCODE_INFO));
}
MicrocodeFmpPrivate->DescriptorCount = CurrentMicrocodeCount;
if (MicrocodeFmpPrivate->ImageDescriptor == NULL) {
MicrocodeFmpPrivate->ImageDescriptor = AllocateZeroPool(MicrocodeFmpPrivate->DescriptorCount * sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR));
if (MicrocodeFmpPrivate->ImageDescriptor == NULL) {
return EFI_OUT_OF_RESOURCES;
}
}
if (MicrocodeFmpPrivate->MicrocodeInfo == NULL) {
MicrocodeFmpPrivate->MicrocodeInfo = AllocateZeroPool(MicrocodeFmpPrivate->DescriptorCount * sizeof(MICROCODE_INFO));
if (MicrocodeFmpPrivate->MicrocodeInfo == NULL) {
FreePool (MicrocodeFmpPrivate->ImageDescriptor);
return EFI_OUT_OF_RESOURCES;
}
}
CurrentMicrocodeCount = (UINT8)GetMicrocodeInfo (MicrocodeFmpPrivate, MicrocodeFmpPrivate->DescriptorCount, MicrocodeFmpPrivate->ImageDescriptor, MicrocodeFmpPrivate->MicrocodeInfo);
ASSERT(CurrentMicrocodeCount == MicrocodeFmpPrivate->DescriptorCount);
InitializedProcessorMicrocodeIndex (MicrocodeFmpPrivate);
Status = InitializeFitMicrocodeInfo (MicrocodeFmpPrivate);
if (EFI_ERROR(Status)) {
//
// Error handling Fit Microcode init failure.
// Switch to non-fit update mode and don't return failure
//
// FreePool (MicrocodeFmpPrivate->ImageDescriptor);
// FreePool (MicrocodeFmpPrivate->MicrocodeInfo);
DEBUG ((DEBUG_ERROR, "InitializeFitMicrocodeInfo - %r\n", Status));
DEBUG ((DEBUG_ERROR, "Force switch to Non-FIT mode\n", Status));
MicrocodeFmpPrivate->FitMicrocodeEntryCount = 0;
}
return EFI_SUCCESS;
}
/**
Initialize MicrocodeFmpDriver multiprocessor information.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
@return EFI_SUCCESS Processor information is initialized.
@return EFI_OUT_OF_RESOURCES No enough resource for the initialization.
**/
EFI_STATUS
InitializeProcessorInfo (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
EFI_STATUS Status;
EFI_MP_SERVICES_PROTOCOL *MpService;
UINTN NumberOfPhysicalProcessors;
UINTN NumberOfEnabledProcessors;
UINTN Index;
UINTN CpuIndex;
UINTN BspIndex;
MICROCODE_SELECTION_POLICY *MicrocodePolicy;
UINTN PolicySize;
UINTN PolicyNum;
Status = gBS->LocateProtocol (&gEfiMpServiceProtocolGuid, NULL, (VOID **)&MpService);
ASSERT_EFI_ERROR(Status);
MicrocodeFmpPrivate->MpService = MpService;
MicrocodeFmpPrivate->ProcessorCount = 0;
MicrocodeFmpPrivate->ProcessorInfo = NULL;
Status = MpService->GetNumberOfProcessors (MpService, &NumberOfPhysicalProcessors, &NumberOfEnabledProcessors);
ASSERT_EFI_ERROR(Status);
MicrocodeFmpPrivate->ProcessorCount = NumberOfPhysicalProcessors; //8
Status = MpService->WhoAmI (MpService, &BspIndex);
ASSERT_EFI_ERROR(Status);
MicrocodeFmpPrivate->BspIndex = BspIndex;
//
// Collect PolicyProcessInfo from uCode selection PolicyPcd
//
MicrocodePolicy = (MICROCODE_SELECTION_POLICY *) PcdGetPtr(PcduCodeSelectionPolicy);
PolicySize = PcdGetSize(PcduCodeSelectionPolicy);
if ((PolicySize & 0x7) == 0) {
PolicyNum = (PolicySize >> 3);
} else {
DEBUG ((DEBUG_INFO, "PcduCodeSelectionPolicy size %x is not mutiple of 8. Treat it as empty\n", PolicySize));
PolicyNum = 0;
}
DEBUG ((DEBUG_INFO, "PcduCodeSelectionPolicy PolicyNum %x\n", PolicyNum));
MicrocodeFmpPrivate->ProcessorInfo = AllocateZeroPool (sizeof(PROCESSOR_INFO) * (NumberOfPhysicalProcessors + PolicyNum));
if (MicrocodeFmpPrivate->ProcessorInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
for (CpuIndex = 0; CpuIndex < NumberOfPhysicalProcessors; CpuIndex++) {
MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].CpuIndex = CpuIndex;
MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].MicrocodeIndex = (UINTN)-1;
MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].IsRealCpu = TRUE;
if (CpuIndex == BspIndex) {
CollectProcessorInfo (&MicrocodeFmpPrivate->ProcessorInfo[CpuIndex]);
} else {
Status = MpService->StartupThisAP (
MpService,
CollectProcessorInfo,
CpuIndex,
NULL,
0,
&MicrocodeFmpPrivate->ProcessorInfo[CpuIndex],
NULL
);
ASSERT_EFI_ERROR(Status);
}
}
//
// If uCode Selection Policy is not empty.
// 1) Validate current CPU setting with Selection Policy
// 2) Add CPU in Policy that isn't current CPU on board as Logic CPU (IsRealCpu = FALSE)
//
if (PolicyNum > 0) { //PolicyNum = 0
//
// Check if there is mis-configuration of PcduCodeSelectionPolicy that doesn't include current physical CPU on the platform
//
DEBUG ((DEBUG_INFO, "PolicyNum = 0x%08X\n", PolicyNum));
for (CpuIndex = 0; CpuIndex < NumberOfPhysicalProcessors; CpuIndex++) {
for (Index = 0; Index < PolicyNum; Index++) {
DEBUG ((DEBUG_INFO, "MicrocodeFmpPrivate->ProcessorInfo[%d].ProcessorSignature 0x%08X\n", CpuIndex, MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorSignature));
DEBUG ((DEBUG_INFO, "MicrocodePolicy[%d].ProcessorSignature 0x%08X\n", Index, MicrocodePolicy[Index].ProcessorSignature));
DEBUG ((DEBUG_INFO, "MicrocodeFmpPrivate->ProcessorInfo[%d].ProcessorFlags 0x%08X\n", CpuIndex, MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorFlags));
DEBUG ((DEBUG_INFO, "MicrocodePolicy[%d].ProcessorFlags 0x%08X\n", Index, MicrocodePolicy[Index].ProcessorFlags));
if ((MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorSignature == MicrocodePolicy[Index].ProcessorSignature) &&
(MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorFlags == MicrocodePolicy[Index].ProcessorFlags)) {
break;
}
}
// if (Index == PolicyNum) {
// DEBUG ((DEBUG_ERROR, "Current CPU on Platform is not found in PcduCodeSelectionPolicy\n"));
// DEBUG ((DEBUG_ERROR, "ProcessorSignature %x\n", MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorSignature));
// DEBUG ((DEBUG_ERROR, "ProcessorFlags %x\n", MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorFlags));
// ASSERT(FALSE);
// return EFI_INVALID_PARAMETER;
// }
}
//
// Add Logic CPU that is defined in PcduCodeSelectionPolicy which is not current physical CPU on the platform
//
for (Index = 0; Index < PolicyNum; Index++) {
for (CpuIndex = 0; CpuIndex < NumberOfPhysicalProcessors; CpuIndex++) {
if ((MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorSignature == MicrocodePolicy[Index].ProcessorSignature) &&
(MicrocodeFmpPrivate->ProcessorInfo[CpuIndex].ProcessorFlags == MicrocodePolicy[Index].ProcessorFlags)) {
break;
}
}
//
// If CPU identified in PcduCodeSelectionPolicy is not present on this platform. Mark it to be a logic CPU
//
if (CpuIndex == NumberOfPhysicalProcessors) {
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].CpuIndex = MicrocodeFmpPrivate->ProcessorCount;
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].ProcessorSignature = MicrocodePolicy[Index].ProcessorSignature;
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].ProcessorFlags = MicrocodePolicy[Index].ProcessorFlags;
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].MicrocodeRevision = (UINT32)-1;
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].MicrocodeIndex = (UINTN)-1;
MicrocodeFmpPrivate->ProcessorInfo[MicrocodeFmpPrivate->ProcessorCount].IsRealCpu = FALSE;
MicrocodeFmpPrivate->ProcessorCount++;
}
}
}
return EFI_SUCCESS;
}
/**
Dump private information.
@param[in] MicrocodeFmpPrivate private data structure.
**/
VOID
DumpPrivateInfo (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
UINTN Index;
PROCESSOR_INFO *ProcessorInfo;
MICROCODE_INFO *MicrocodeInfo;
EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor;
FIT_MICROCODE_INFO *FitMicrocodeInfo;
DEBUG ((DEBUG_INFO, "ProcessorInfo:\n"));
DEBUG ((DEBUG_INFO, " ProcessorCount - 0x%x\n", MicrocodeFmpPrivate->ProcessorCount));
DEBUG ((DEBUG_INFO, " BspIndex - 0x%x\n", MicrocodeFmpPrivate->BspIndex));
ProcessorInfo = MicrocodeFmpPrivate->ProcessorInfo;
for (Index = 0; Index < MicrocodeFmpPrivate->ProcessorCount; Index++) {
DEBUG ((
DEBUG_INFO,
" Existing ProcessorInfo[0x%x] %a - 0x%08x, 0x%02x, 0x%02x, 0x%08x, (0x%x)\n",
ProcessorInfo[Index].CpuIndex,
ProcessorInfo[Index].IsRealCpu ? "PhysicalCpu" : "LogicCpu",
ProcessorInfo[Index].ProcessorSignature,
ProcessorInfo[Index].PlatformId,
ProcessorInfo[Index].ProcessorFlags,
ProcessorInfo[Index].MicrocodeRevision,
ProcessorInfo[Index].MicrocodeIndex
));
}
DEBUG ((DEBUG_INFO, "MicrocodeInfo:\n"));
MicrocodeInfo = MicrocodeFmpPrivate->MicrocodeInfo;
DEBUG ((DEBUG_INFO, " MicrocodeRegion - 0x%x - 0x%x\n", MicrocodeFmpPrivate->MicrocodePatchAddress, MicrocodeFmpPrivate->MicrocodePatchRegionSize));
DEBUG ((DEBUG_INFO, " MicrocodeCount - 0x%x\n", MicrocodeFmpPrivate->DescriptorCount));
for (Index = 0; Index < MicrocodeFmpPrivate->DescriptorCount; Index++) {
DEBUG ((
DEBUG_INFO,
" MicrocodeInfo[0x%x] - 0x%08x, 0x%08x, (0x%x)\n",
Index,
MicrocodeInfo[Index].MicrocodeEntryPoint,
MicrocodeInfo[Index].TotalSize,
MicrocodeInfo[Index].InUse
));
}
ImageDescriptor = MicrocodeFmpPrivate->ImageDescriptor;
DEBUG ((DEBUG_VERBOSE, "ImageDescriptor:\n"));
for (Index = 0; Index < MicrocodeFmpPrivate->DescriptorCount; Index++) {
DEBUG ((DEBUG_VERBOSE, " ImageDescriptor (%d)\n", Index));
DEBUG ((DEBUG_VERBOSE, " ImageIndex - 0x%x\n", ImageDescriptor[Index].ImageIndex));
DEBUG ((DEBUG_VERBOSE, " ImageTypeId - %g\n", &ImageDescriptor[Index].ImageTypeId));
DEBUG ((DEBUG_VERBOSE, " ImageId - 0x%lx\n", ImageDescriptor[Index].ImageId));
DEBUG ((DEBUG_VERBOSE, " ImageIdName - %s\n", ImageDescriptor[Index].ImageIdName));
DEBUG ((DEBUG_VERBOSE, " Version - 0x%x\n", ImageDescriptor[Index].Version));
DEBUG ((DEBUG_VERBOSE, " VersionName - %s\n", ImageDescriptor[Index].VersionName));
DEBUG ((DEBUG_VERBOSE, " Size - 0x%x\n", ImageDescriptor[Index].Size));
DEBUG ((DEBUG_VERBOSE, " AttributesSupported - 0x%lx\n", ImageDescriptor[Index].AttributesSupported));
DEBUG ((DEBUG_VERBOSE, " AttributesSetting - 0x%lx\n", ImageDescriptor[Index].AttributesSetting));
DEBUG ((DEBUG_VERBOSE, " Compatibilities - 0x%lx\n", ImageDescriptor[Index].Compatibilities));
DEBUG ((DEBUG_VERBOSE, " LowestSupportedImageVersion - 0x%x\n", ImageDescriptor[Index].LowestSupportedImageVersion));
DEBUG ((DEBUG_VERBOSE, " LastAttemptVersion - 0x%x\n", ImageDescriptor[Index].LastAttemptVersion));
DEBUG ((DEBUG_VERBOSE, " LastAttemptStatus - 0x%x\n", ImageDescriptor[Index].LastAttemptStatus));
DEBUG ((DEBUG_VERBOSE, " HardwareInstance - 0x%lx\n", ImageDescriptor[Index].HardwareInstance));
}
if (MicrocodeFmpPrivate->FitMicrocodeInfo != NULL) {
DEBUG ((DEBUG_INFO, "FitMicrocodeInfo:\n"));
FitMicrocodeInfo = MicrocodeFmpPrivate->FitMicrocodeInfo;
DEBUG ((DEBUG_INFO, " FitMicrocodeEntryCount - 0x%x\n", MicrocodeFmpPrivate->FitMicrocodeEntryCount));
for (Index = 0; Index < MicrocodeFmpPrivate->FitMicrocodeEntryCount; Index++) {
DEBUG ((
DEBUG_INFO,
" FitMicrocodeInfo[0x%x] - 0x%08x, 0x%08x, (0x%x, 0x%x)\n",
Index,
FitMicrocodeInfo[Index].MicrocodeEntryPoint,
FitMicrocodeInfo[Index].TotalSize,
FitMicrocodeInfo[Index].InUse,
FitMicrocodeInfo[Index].Empty
));
}
}
}
/**
Initialize MicrocodeFmpDriver private data structure.
@param[in] MicrocodeFmpPrivate private data structure to be initialized.
@return EFI_SUCCESS private data is initialized.
**/
EFI_STATUS
InitializeMicrocodePrivateData (
IN MICROCODE_FMP_PRIVATE_DATA *MicrocodeFmpPrivate
)
{
EFI_STATUS Status;
UINTN VarSize;
BOOLEAN Result;
UINT32 AttemptVersion;
ESRT_STATUS AttemptStatus;
UINT64 OsIndications;
UINT64 Size;
MicrocodeFmpPrivate->Signature = MICROCODE_FMP_PRIVATE_DATA_SIGNATURE;
MicrocodeFmpPrivate->PackageVersion = 0x1;
MicrocodeFmpPrivate->PackageVersionName = L"Microcode";
VarSize = sizeof(UINT32);
Status = gRT->GetVariable (
ESRT_LAST_ATTEMPT_VERSION,
PcdGetPtr (PcdWindowsUcodeFirmwareCapsuleGuid),
NULL,
&VarSize,
&AttemptVersion
);
if (!EFI_ERROR(Status)) {
MicrocodeFmpPrivate->LastAttempt.LastAttemptVersion = AttemptVersion;
}
VarSize = sizeof(ESRT_STATUS);
Status = gRT->GetVariable (
ESRT_LAST_ATTEMPT_STATUS,
PcdGetPtr (PcdWindowsUcodeFirmwareCapsuleGuid),
NULL,
&VarSize,
&AttemptStatus
);
if (!EFI_ERROR(Status)) {
MicrocodeFmpPrivate->LastAttempt.LastAttemptStatus = AttemptStatus;
}
DEBUG ((DEBUG_INFO, "GetLastAttempt Version - 0x%x, State - 0x%x\n", MicrocodeFmpPrivate->LastAttempt.LastAttemptVersion, MicrocodeFmpPrivate->LastAttempt.LastAttemptStatus));
//FvMicodecode
Result = GetMicrocodeRegion(&MicrocodeFmpPrivate->MicrocodePatchAddress, &MicrocodeFmpPrivate->MicrocodePatchRegionSize);
if (!Result) {
DEBUG ((DEBUG_ERROR, "Fail to get Microcode Region\n"));
return EFI_NOT_FOUND;
}
//Onboard micricodeversion.data
Status = GetMicrocodeRegionVersionInfo((UINT8 **)&MicrocodeFmpPrivate->VersionInfo, &MicrocodeFmpPrivate->VersionInfoSize);
if (EFI_ERROR(Status)) {
ASSERT(MicrocodeFmpPrivate->VersionInfo != NULL);
return EFI_INVALID_PARAMETER;
}
DEBUG ((DEBUG_INFO, "Current Microcode Region Version : %x\n", MicrocodeFmpPrivate->VersionInfo->Version));
DEBUG ((DEBUG_INFO, " Lowest Support Version : %x\n", MicrocodeFmpPrivate->VersionInfo->LowestSupportedVersion));
DEBUG ((DEBUG_INFO, " Version Info String : %s\n", MicrocodeFmpPrivate->VersionInfo->VersionString));
//
// Init Processor info. Processor Info comes from 2 sources
// 1. uCode Selection Policy PCD
// 2. Existing CPU onboard
//
Size = sizeof(UINT64);
OsIndications = 0;
Status = gRT->GetVariable (
L"OsIndications",
&gEfiGlobalVariableGuid,
NULL,
&Size,
&OsIndications
);
if ((OsIndications & (EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED))) {
Status = InitializeProcessorInfo (MicrocodeFmpPrivate);
if (EFI_ERROR(Status)) {
DEBUG ((DEBUG_ERROR, "InitializeProcessorInfo - %r\n", Status));
return Status;
}
Status = InitializeMicrocodeDescriptor(MicrocodeFmpPrivate);
if (EFI_ERROR(Status)) {
FreePool (MicrocodeFmpPrivate->ProcessorInfo);
DEBUG ((DEBUG_ERROR, "InitializeMicrocodeDescriptor - %r\n", Status));
return Status;
}
} else {
Status = EFI_SUCCESS;
}
DumpPrivateInfo (MicrocodeFmpPrivate);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink