diff options
Diffstat (limited to 'Core/CPU/MicrocodeUpdate/MicrocodeUpdate.c')
| -rw-r--r-- | Core/CPU/MicrocodeUpdate/MicrocodeUpdate.c | 1164 |
1 files changed, 1164 insertions, 0 deletions
diff --git a/Core/CPU/MicrocodeUpdate/MicrocodeUpdate.c b/Core/CPU/MicrocodeUpdate/MicrocodeUpdate.c new file mode 100644 index 0000000..bc3b696 --- /dev/null +++ b/Core/CPU/MicrocodeUpdate/MicrocodeUpdate.c @@ -0,0 +1,1164 @@ +//************************************************************************* +//************************************************************************* +//** ** +//** (C)Copyright 1987-2013, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//************************************************************************* +//************************************************************************* + +//**************************************************************************** +// $Header: /Alaska/SOURCE/Modules/SharkBayRefCodes/Haswell/AMI Cpu PKG/CPU Core/MicrocodeUpdate/MicrocodeUpdate.c 4 4/14/15 2:48a Crystallee $ +// +// $Revision: 4 $ +// +// $Date: 4/14/15 2:48a $ +// +//**************************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Modules/SharkBayRefCodes/Haswell/AMI Cpu PKG/CPU Core/MicrocodeUpdate/MicrocodeUpdate.c $ +// +// 4 4/14/15 2:48a Crystallee +// +// 3 5/15/14 2:32a Crystallee +// [TAG] EIP169079 +// [Category] Improvement +// [Description] Security Enhancement for SMIHandler in Microcode update +// SWSMI. +// +// 2 10/28/12 11:23p Davidhsieh +// [TAG] EIP104874 +// [Category] Improvement +// [Description] Add signature check before search microcode ffs +// +// 1 2/07/12 3:59a Davidhsieh +// +// +//**************************************************************************** + +//<AMI_FHDR_START> +//---------------------------------------------------------------------------- +// +// Name: MicrocodeUpdate.c +// +// Description: Microcode Update SMI handler. +// This file contains code for processing Interrupt 15 function +// D042h, and for registering the callback that does the processing. +// +//---------------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include <Protocol\SmmBase.h> +#include <Protocol\SmmSwDispatch.h> +#include <token.h> +#include <AmiDxeLib.h> +#include <Ffs.h> +#include <AmiCspLibInc.h> +#include "MicrocodeUpdate.h" +#include <AmiSmm.h> +#include <AmiHobs.h> + +#ifndef INT15_D042_SWSMI +#define INT15_D042_SWSMI 0x44 +#endif + +#pragma optimize("", off) + +EFI_GUID gMcodeFfsguid = + {0x17088572, 0x377F, 0x44ef, 0x8F,0x4E,0xB0,0x9F,0xFF,0x46,0xA0,0x70}; + +EFI_GUID gSwSmiCpuTriggerGuid = SW_SMI_CPU_TRIGGER_GUID; + +#if MICROCODE_SPLIT_BB_UPDATE +UINT8 *gMcodeFlashStartFixed = 0; +UINT32 gMcodeFlashSizeFixed = 0; +#endif + +UINT8 *gMcodeFlashStartUpdate = 0; +UINT32 gMcodeFlashSizeUpdate = 0; + +typedef enum { + MCODE_BLK_EMPTY = 0, + MCODE_BLK_START, + MCODE_BLK_CONT +} MCODE_BLK_TYPE; + +typedef struct { + UINT8 *Addr; + UINT32 Size; //0 if less than 64k + MCODE_BLK_TYPE Type; +} MCODE_BLK_MAP; + +UINT16 gNumMcodeBlks = 0; +UINT16 gFirstEmptyBlk = 0xffff; +MCODE_BLK_MAP *gMcodeBlkMap = NULL; + +UINT32 gCpuSignature; +UINT8 gCpuFlag; +UINT32 gUcRevision; + +SMM_HOB gSmmHob; + +#define MAX_MICROCODE_UPDATE_FUNCTIONS 4 +VOID(*MicrocodeUpdate[4])(SMI_UC_DWORD_REGS *) = { + PresenceTest, WriteUpdateData, UpdateControl, ReadUpdateData +}; + +#define MICROCODE_SIZE(Hdr) \ + (((MICROCODE_HEADER*)(Hdr))->TotalSize ? ((MICROCODE_HEADER*)Hdr)->TotalSize : 2048) + +#if PACK_MICROCODE +#define MICROCODE_ALIGN_SIZE(Hdr) \ + ((MICROCODE_SIZE(Hdr) + 16 - 1) & ~(16 - 1)) +#else +#define MICROCODE_ALIGN_SIZE(Hdr) \ + ((MICROCODE_SIZE(Hdr) + MICROCODE_BLOCK_SIZE - 1) & ~(MICROCODE_BLOCK_SIZE - 1)) +#endif + +#if PACK_MICROCODE +#define MICROCODE_BLOCKS(Hdr) \ + ((((MICROCODE_SIZE(Hdr) + MICROCODE_BLOCK_SIZE - 1) & ~(MICROCODE_BLOCK_SIZE - 1)))/MICROCODE_BLOCK_SIZE) +#else + #define MICROCODE_BLOCKS(Hdr) (MICROCODE_ALIGN_SIZE(Hdr)/MICROCODE_BLOCK_SIZE) +#endif + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Procedure: CheckAddressRange +// +// Description: Check address range to avoid TSEG area. +// +// Input: +// Address - starting address +// Range - length of the area +// +// Output: +// EFI_SUCCESS - Access granted +// EFI_ACCESS_DENIED - Access denied! +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS CheckAddressRange( IN UINT8 *Address, IN UINTN Range ) +{ + // Check the size and range + if ( ((EFI_PHYSICAL_ADDRESS)Address >= gSmmHob.Tseg) && + ((EFI_PHYSICAL_ADDRESS)Address <= (gSmmHob.Tseg + gSmmHob.TsegLength)) ) + return EFI_ACCESS_DENIED; + + if ( (((EFI_PHYSICAL_ADDRESS)Address + Range) >= gSmmHob.Tseg) && + (((EFI_PHYSICAL_ADDRESS)Address + Range) <= (gSmmHob.Tseg + gSmmHob.TsegLength)) ) + return EFI_ACCESS_DENIED; + + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsValidHeader +// +// Description: Check if the header is valid. +// +// Input: MICROCODE_HEADER *uHeader -- Address of Microcode Header. +// +// Output: BOOLEAN -- TRUE if microcode header is valid. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN IsValidHeader(MICROCODE_HEADER *uHeader) +{ + if (uHeader->HeaderVersion != UC_HEADER_VERSION) return FALSE; + if (uHeader->LoaderRevison != UC_LOADER_REVISION) return FALSE; + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsValidChecksum +// +// Description: Validate the checksum. +// +// Input: +// VOID *Microcode - Address of Microcode Header. +// UINT32 Size - Microcode Size. +// +// Output: BOOLEAN -- TRUE if checksum is valid. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN IsValidChecksum(VOID *Mcode, UINT32 Size) +{ + UINT32 NumDwords = Size >> 2; + UINT32 *p32 = (UINT32*)Mcode; + UINT32 Checksum = 0; + UINT32 i; + + for(i = 0; i < NumDwords; ++i) Checksum += p32[i]; //Checksum is the summation dwords. + + return Checksum == 0 ? TRUE : FALSE; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetInstalledMicrocodeRevision +// +// Description: Get the installed microcode revision on the cpu. +// +// Input: VOID +// +// Output: UINT32 - Revision of microcode currently installed on CPU. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 GetInstalledMicrocodeRevision() +{ + UINT32 RegEax, RegEbx, RegEcx, RegEdx; + + //Clear IA32_BIOS_SIGN_ID of microcode loaded. + WriteMsr(0x8b, 0); //IA32_BIOS_SIGN_ID + + //Reading CPU ID 1, updates the MSR to the microcode revision. + CPULib_CpuID(1, &RegEax, &RegEbx, &RegEcx, &RegEdx); + return (UINT32) Shr64(ReadMsr(0x8b), 32); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CountBlks +// +// Description: Count blocks taken by microcode in FFS. +// +// Input: +// IN UINT8 *McodeStart - Start of microcode in FFS. +// IN UINT32 McodeSize - Size of microcode and empty space in FFS. +// IN BOOLEAN CountEmpty - TRUE if calculate blocks for empty space. +// +// Output: UINT16 - Number of blocks needed. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 CountBlks(IN UINT8 *McodeStart, IN UINT32 McodeSize, IN BOOLEAN CountEmpty) +{ + UINT8 *p = McodeStart; + UINT8 *EndOfMcode = p + McodeSize; + UINT16 TotBlks = 0; + + while(p < EndOfMcode) { + if (*(UINT32*)p != 0xffffffff && *(UINT32*)p != 0) { + TotBlks += MICROCODE_BLOCKS(p); + p += MICROCODE_ALIGN_SIZE(p); + } else if (CountEmpty) { + TotBlks += (UINT16)((EndOfMcode - p) / MICROCODE_BLOCK_SIZE); + break; + } + else break; + } + + return TotBlks; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FillMicrocodeBlkMap +// +// Description: Update gMcodeBlkMap with data for microcode. +// +// Input: +// IN OUT *BlkStart - On Input: Start update with this block. Output: Next call use this value. +// IN UINT8 *McodeStart - Start of microcode in FFS. +// IN UINT32 McodeSize - Size of microcode and empty space in FFS. +// IN BOOLEAN CountEmpty - TRUE if update blocks for empty space. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID FillMicrocodeBlkMap(IN OUT UINT16 *BlkStart, IN UINT8 *McodeStart, IN UINT32 McodeSize, IN BOOLEAN CountEmpty) +{ + UINT8 *p = McodeStart; + UINT8 *EndOfMcode = p + McodeSize; + UINT16 BlkIndex = *BlkStart; + + while(p < EndOfMcode) { + if (*(UINT32*)p != 0xffffffff && *(UINT32*)p != 0) { + UINT16 NumBlks = MICROCODE_BLOCKS(p); + UINT32 McodeSize = MICROCODE_SIZE(p); +#if PACK_MICROCODE == 0 + UINT32 PackDiff = MICROCODE_ALIGN_SIZE(p) - McodeSize; +#endif + + gMcodeBlkMap[BlkIndex].Addr = p; + gMcodeBlkMap[BlkIndex].Size = MICROCODE_BLOCK_SIZE; + gMcodeBlkMap[BlkIndex].Type = MCODE_BLK_START; + if (NumBlks <= 1 && McodeSize < MICROCODE_BLOCK_SIZE) { + gMcodeBlkMap[BlkIndex].Size = McodeSize; + } + p += gMcodeBlkMap[BlkIndex].Size; + McodeSize -= gMcodeBlkMap[BlkIndex].Size; + ++BlkIndex; + while(--NumBlks) { + gMcodeBlkMap[BlkIndex].Addr = p; + gMcodeBlkMap[BlkIndex].Size = MICROCODE_BLOCK_SIZE; + gMcodeBlkMap[BlkIndex].Type = MCODE_BLK_CONT; + if (NumBlks == 1 && McodeSize < MICROCODE_BLOCK_SIZE) { + gMcodeBlkMap[BlkIndex].Size = McodeSize; + } + p += gMcodeBlkMap[BlkIndex].Size; + McodeSize -= gMcodeBlkMap[BlkIndex].Size; + ++BlkIndex; + } +#if PACK_MICROCODE == 0 + p += PackDiff; +#endif + } else if (CountEmpty) { + gFirstEmptyBlk = BlkIndex; + while (BlkIndex < gNumMcodeBlks) { + gMcodeBlkMap[BlkIndex].Addr = p; + gMcodeBlkMap[BlkIndex].Size = MICROCODE_BLOCK_SIZE; + gMcodeBlkMap[BlkIndex].Type = MCODE_BLK_EMPTY; + BlkIndex++; + } + break; + } else break; + } + *BlkStart = BlkIndex; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InitMcodeBlkMap +// +// Description: Initialize gMcodeBlkMap and related globals for all microcode FFS. +// +// Input: VOID +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID InitMcodeBlkMap() +{ + UINT16 BlkStart = 0; + + if (gMcodeBlkMap != NULL) pSmst->SmmFreePool(gMcodeBlkMap); + gNumMcodeBlks = 0; +#if MICROCODE_SPLIT_BB_UPDATE + gNumMcodeBlks += CountBlks(gMcodeFlashStartFixed, gMcodeFlashSizeFixed, FALSE); +#endif + gNumMcodeBlks += CountBlks(gMcodeFlashStartUpdate, gMcodeFlashSizeUpdate, TRUE); + + pSmst->SmmAllocatePool(0, gNumMcodeBlks * sizeof(MCODE_BLK_MAP), &gMcodeBlkMap); + + gFirstEmptyBlk = 0xffff; +#if MICROCODE_SPLIT_BB_UPDATE + FillMicrocodeBlkMap(&BlkStart, gMcodeFlashStartFixed, gMcodeFlashSizeFixed, FALSE); +#endif + FillMicrocodeBlkMap(&BlkStart, gMcodeFlashStartUpdate, gMcodeFlashSizeUpdate, TRUE); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FindMicrocodeFfs +// +// Description: Find Micorode FFS in FV. +// +// Input: IN EFI_FIRMWARE_VOLUME_HEADER *FvHdr - Firmware volume to search +// +// Output: UINT8 * - Return FFS. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 *FindMicrocodeFfs(IN EFI_FIRMWARE_VOLUME_HEADER *FvHdr) +{ + UINT8 *FvPtr = (UINT8*)FvHdr + FvHdr->HeaderLength; + UINT8 *EndOfFv = (UINT8*)FvHdr + FvHdr->FvLength; + + //Check for corrupt firmware volume. + if (FvHdr->Signature != 'HVF_') return NULL; + //Search the FV_MAIN firmware volume for the microcode file. + while (FvPtr < EndOfFv && *FvPtr != -1) { + if (guidcmp(&gMcodeFfsguid, &((EFI_FFS_FILE_HEADER*)FvPtr)->Name)==0) + return FvPtr; + + FvPtr += *(UINT32*)&((EFI_FFS_FILE_HEADER*)FvPtr)->Size & 0xffffff; + FvPtr = (UINT8*)(((UINTN)FvPtr + 7) & ~7); //8 byte alignment + } + return NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InitMicrocodeVariables +// +// Description: Initialize global variables used by the driver. +// +// Input: VOID +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN InitMicrocodeVariables() +{ + UINT8 *FfsPtr; + UINT32 McodeFfsSize; + UINT64 MsrValue; + UINT32 RegEbx, RegEcx, RegEdx; +#if MICROCODE_SPLIT_BB_UPDATE + UINT16 MPDTLengthFixed; +#endif + UINT16 MPDTLengthUpdate; + +#if MICROCODE_SPLIT_BB_UPDATE + FfsPtr = FindMicrocodeFfs((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)FV_MICROCODE_BASE); + if (FfsPtr == NULL) return FALSE; + + gMcodeFlashStartFixed = FfsPtr + sizeof(EFI_FFS_FILE_HEADER); + McodeFfsSize = ((*(UINT32*)((EFI_FFS_FILE_HEADER*)FfsPtr)->Size) & 0xffffff); +#if MPDTable_CREATED + MPDTLengthFixed = *(UINT16*)(FfsPtr + McodeFfsSize - 2); //Last 2 bytes is table size. +#else + MPDTLengthFixed = 0; +#endif + gMcodeFlashSizeFixed = McodeFfsSize - sizeof(EFI_FFS_FILE_HEADER) - MPDTLengthFixed; +#endif + +#if MICROCODE_SPLIT_BB_UPDATE + FfsPtr = FindMicrocodeFfs((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)FV_MICROCODE_UPDATE_BASE); +#else + FfsPtr = FindMicrocodeFfs((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)FV_MICROCODE_BASE); +#endif + if (FfsPtr == NULL) return FALSE; + + gMcodeFlashStartUpdate = FfsPtr + sizeof(EFI_FFS_FILE_HEADER); + McodeFfsSize = ((*(UINT32*)((EFI_FFS_FILE_HEADER*)FfsPtr)->Size) & 0xffffff); +#if MPDTable_CREATED + MPDTLengthUpdate = *(UINT16*)(FfsPtr + McodeFfsSize - 2); //Last 2 bytes is table size. +#else + MPDTLengthUpdate = 0; +#endif + gMcodeFlashSizeUpdate = McodeFfsSize - sizeof(EFI_FFS_FILE_HEADER) - MPDTLengthUpdate; + + InitMcodeBlkMap(); + + //Clear revision value. CPUID of 1 will update this revision value. + WriteMsr(0x8b, 0); //IA32_BIOS_SIGN_ID + + CPULib_CpuID(1, &gCpuSignature, &RegEbx, &RegEcx, &RegEdx); + gCpuSignature &= 0x00ffffff; + MsrValue = ReadMsr(0x17); + gCpuFlag = (UINT8)(Shr64(MsrValue, 50) & 7); //Get the CPU flags. + gUcRevision = (UINT32) Shr64(ReadMsr(0x8b), 32); //Get the current microcode revision loaded. + + return TRUE; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FindMicrocodeOfStepping +// +// Description: Search the microcode in the firmware for the cpu signature +// or earlier steping. +// +// Input: +// UINT8 *Mcode - Address of Mcode Header. +// UINT8 *End - Mcode End. +// UINT32 CpuSignature - Signature of CPU to find. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID *FindMicrocodeOfStepping(UINT8 *Mcode, UINT8 *End, UINT32 CpuSignature) +{ + UINT8 *ptr; + for(ptr = Mcode; ptr < End; ptr += MICROCODE_ALIGN_SIZE(ptr)) { + MICROCODE_HEADER* uC = (MICROCODE_HEADER*)ptr; + + if (*(UINT32*)ptr == 0xffffffff || *(UINT32*)ptr == 0) return 0; + if (uC->CpuSignature == CpuSignature) return ptr; + + if (uC->TotalSize > (uC->DataSize + 48)) { //Extended signature count. + MICROCODE_EXT_PROC_SIG_TABLE *SigTable = (MICROCODE_EXT_PROC_SIG_TABLE*)(ptr + uC->DataSize + 48); + UINT32 ExtSigCount = SigTable->Count; + UINT8 i; + + for (i = 0; i < ExtSigCount; ++i) { + if (SigTable->ProcSig[i].CpuSignature == CpuSignature) return ptr; + } + } + } + return 0; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: LoadMicrocode +// +// Description: Load the microcode onto the CPU. +// +// Input: +// VOID *Mcode - Address of Microcode Header. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID LoadMicrocode(IN VOID *Mcode) +{ + WriteMsr(0x79, (UINT64)(UINTN)Mcode + 48); //IA32_BIOS_UPDT_TRIG +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: LoadMicrocodeEachCpu +// +// Description: Load the microcode on each CPU. +// +// Input: EFI_SMI_CPU_SAVE_STATE *CpuSaveState +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID LoadMicrocodeEachCpu(IN VOID *Mcode) +{ + UINT8 i; + //In for loop, BSP CPU will return error and continue for all APs. + for (i = 0; i < pSmst->NumberOfCpus; ++i) { + pSmst->SmmStartupThisAp(LoadMicrocode, i, Mcode); + } + LoadMicrocode(Mcode); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: PresenceTest +// +// Description: Execute the presence test function for int 15h. +// +// Input: SMI_UC_DWORD_REGS *Regs +// +// Output: VOID +// +// Notes: +// +// Input: +// AX - D042h +// BL - 00h i.e., PRESCENCE_TEST +// +// Output: +// CF NC - All return values are valid +// CY - Failure, AH contains status. +// +// AH Return code +// AL Additional OEM information +// EBX Part one of the signature 'INTE'. +// ECX Part two of the signature 'LPEP'. +// EDX Version number of the BIOS update loader +// SI Number of update blocks system can record in NVRAM (1 based). +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID PresenceTest(SMI_UC_DWORD_REGS *Regs) +{ + Regs->EBX = 'INTE'; //Part 1 of the Signature + Regs->ECX = 'LPEP'; //Part 2 of the Signature. + Regs->EDX = UC_LOADER_VERSION; + + *(UINT16*)&Regs->ESI = gNumMcodeBlks; //Number of blocks. +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UpdateControl +// +// Description: Execute the update control for int 15h. +// +// Input: SMI_UC_DWORD_REGS *Regs +// +// Output: VOID +// +// Notes: +// Input: +// AX - D042h +// BL - 02h i.e., UPDATE_CONTROL +// BH - Task +// 1 - Enable the update loading at initialization time. +// 2 - Determine the current state of the update control without changing its status. +// +// Output: +// AH Return code +// AL Additional OEM information +// BL Update status Disable or Enable. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID UpdateControl(SMI_UC_DWORD_REGS *Regs) +{ + + //This is checking for a task of 0 or > 2. This is not in the specification, but in Intel code. + if ((Regs->EBX & 0xff00) == 0 || (Regs->EBX & 0x0ff00) > 0x200) { //Check BH + // Indicate we cannot determinate the Enable/Disable status via CMOS + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_READ_FAILURE; + } + + Regs->EBX = (Regs->EBX & 0xffffff00) | UC_INT15_ENABLE; // Always enabled. +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadUpdateData +// +// Description: Read microcode using int15h. +// +// Input: SMI_UC_DWORD_REGS *Regs +// +// Output: VOID +// +// Notes: +// +// Input: +// AX - D042h +// BL - 03h i.e., READ_UPDATE_DATA +// ES:DI - Real Mode Pointer to the Intel Update structure. +// SS:SP - Stack pointer (32K minimum) +// SI - Update number, the index number of the update block to be read. +// This number is zero based and must be less than the update +// count returned from the prescence test function. +// +// Output: +// AH Return code +// AL Additional OEM information +// BL Update status Disable or Enable. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID ReadUpdateData(SMI_UC_DWORD_REGS *Regs) +{ + EFI_STATUS Status; + UINT16 Index = (UINT16)Regs->ESI; + UINT8 *UpdateBuffer; + MICROCODE_HEADER *Header; + + if (Index >= gNumMcodeBlks) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_UPDATE_NUM_INVALID; + return; + } + + if (gMcodeBlkMap[Index].Type == MCODE_BLK_CONT) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_NOT_EMPTY; + return; + } + + UpdateBuffer = (UINT8*)(UINTN)(((UINT16)Regs->ES << 4) + (UINT16)Regs->EDI); + + Status = CheckAddressRange (UpdateBuffer, MICROCODE_BLOCK_SIZE); + if(EFI_ERROR(Status)) return; + + if (gMcodeBlkMap[Index].Type == MCODE_BLK_EMPTY) { + MemSet(UpdateBuffer, MICROCODE_BLOCK_SIZE, 0xff); + return; + } + + Header = (MICROCODE_HEADER *)gMcodeBlkMap[Index].Addr; + + MemCpy(UpdateBuffer, Header, MICROCODE_SIZE(Header)); +} + + +/////////////////////////////////////////////////////////////////////////////////// + +static UINT8 *gFlashBlk; //Pointer to current flash block to write. +static UINT8 *gFlashBuffer; //Pointer to beginning of buffer. +static UINT8 *gFlashBufferPos; //Pointer to current posisiton. +static UINT32 gFlashBufferUsed; //Number of bytes used in the buffer. + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FlushBufferToFlash +// +// Description: Helper function to write the buffer to the flash and reset the buffer. +// +// Input: VOID +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID FlushBufferToFlash() +{ + FwhErase((UINTN)gFlashBlk, FLASH_BLOCK_SIZE); + FwhWrite(gFlashBuffer, (UINTN)gFlashBlk, FLASH_BLOCK_SIZE); + gFlashBlk += FLASH_BLOCK_SIZE; + gFlashBufferPos = gFlashBuffer; + gFlashBufferUsed = 0; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InitializeFlashBuffer +// +// Description: Initialize the flash buffer before using. +// +// Input: +// IN UINT8* FirstFlashBlk - Address of first block to flash. +// IN UINT8* FlashBuffer - Flash Buffer. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID InitializeFlashBuffer(IN UINT8* FirstFlashBlk, IN UINT8 *FlashBuffer) +{ + gFlashBlk = FirstFlashBlk; + gFlashBuffer = FlashBuffer; + gFlashBufferPos = gFlashBuffer; + gFlashBufferUsed = 0; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: CopyToFlashBuffer +// +// Description: Copy data to the buffer. When the buffer is full, write to the flash, +// and continues to copy data. +// +// Input: +// IN UINT8 Data - Start of data to write. +// IN UINT32 Size - Amount to Write. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID CopyToFlashBuffer(IN UINT8 *Data, IN UINT32 Size) +{ + while (Size) { + if (gFlashBufferUsed + Size <= FLASH_BLOCK_SIZE) { + MemCpy(gFlashBufferPos, Data, Size); + + gFlashBufferPos += Size; + gFlashBufferUsed += Size; + + if (gFlashBufferUsed == FLASH_BLOCK_SIZE) FlushBufferToFlash(); + return; + } + + MemCpy(gFlashBufferPos, Data, FLASH_BLOCK_SIZE - gFlashBufferUsed); + Data += FLASH_BLOCK_SIZE - gFlashBufferUsed; + Size -= FLASH_BLOCK_SIZE - gFlashBufferUsed; + FlushBufferToFlash(); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: WriteValueToFlashBuffer +// +// Description: Fill part of the buffer with a value. When the buffer is full, write to the flash, +// and continue to update the beginning of the buffer with a value. +// +// Input: +// IN UINT8 Value - Value to write. +// IN UINT32 Size - Amount to Write. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID WriteValueToFlashBuffer(IN UINT8 Value, IN UINT32 Size) +{ + + while (Size) { + if (gFlashBufferUsed + Size <= FLASH_BLOCK_SIZE) { + MemSet(gFlashBufferPos, Size, Value); + + gFlashBufferPos += Size; + gFlashBufferUsed += Size; + + if (gFlashBufferUsed == FLASH_BLOCK_SIZE) FlushBufferToFlash(); + return; + } + + MemSet(gFlashBufferPos, FLASH_BLOCK_SIZE - gFlashBufferUsed, Value); + Size -= FLASH_BLOCK_SIZE - gFlashBufferUsed; + FlushBufferToFlash(); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FillBufferAndFlush +// +// Description: Fill the rest of the buffer of a size of the flash block, then update the flash. +// +// Input: IN UINT8 *Data - Pointer to starting of data to write to the flash. +// +// Output: VOID +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID FillFlashBufferAndFlush(IN UINT8 *Data) +{ + if (gFlashBufferUsed != 0) { + MemCpy(gFlashBufferPos, Data, FLASH_BLOCK_SIZE - gFlashBufferUsed); + FwhErase((UINTN)gFlashBlk, FLASH_BLOCK_SIZE); + FwhWrite(gFlashBuffer, (UINTN)gFlashBlk, FLASH_BLOCK_SIZE); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: SMI_UC_DWORD_REGS +// +// Description: Write microcode to flash and load microcode into each CPU. +// +// Input: EFI_SMI_CPU_SAVE_STATE *Regs +// +// Output: VOID +// +// Input: +// AX - D042h +// BL - 01h i.e., WRITE_UPDATE_DATA +// ES:DI - Real Mode Pointer to the Intel Update structure. +// CX - Scratch Pad1 (Real Mode Scratch segment 64K in length) +// DX - Scratch Pad2 (Real Mode Scratch segment 64K in length) +// SI - Scratch Pad3 (Real Mode Scratch segment 64K in length) +// SS:SP - Stack pointer (32K minimum) +// +// Output: +// CF NC - All return values are valid +// CY - Failure, AH contains status. +// +// AH Return code +// AL Additional OEM information +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID WriteUpdateData(SMI_UC_DWORD_REGS *Regs) +{ + EFI_STATUS Status; + UINT8 *NewMcode = (UINT8*)(UINTN)((Regs->ES << 4) + (Regs->EDI & 0xFFFF)); + MICROCODE_HEADER *Header = (MICROCODE_HEADER*)NewMcode; + INT32 NewMcodeAlignSize = MICROCODE_ALIGN_SIZE(NewMcode); + INT32 NewMcodeSize = MICROCODE_SIZE(NewMcode); + BOOLEAN Compact = FALSE; + + UINT8 *OldMcode; + INT32 OldMcodeAlignSize; + UINT8 *BlkStart; + UINT8 *McodeUpdateStart; + UINT8 *Buffer; + + Status = CheckAddressRange(NewMcode, NewMcodeAlignSize); + if(EFI_ERROR(Status)) return; + + if (!IsValidHeader(Header)) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_INVALID_HEADER; + return; + } + + if (!IsValidChecksum(NewMcode, NewMcodeSize)) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_INVALID_HEADER_CS; + return; + } + + //Only update if microcode is for the installed CPU. + if (Header->CpuSignature != gCpuSignature || !(Header->Flags & (1<<gCpuFlag))) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_CPU_NOT_PRESENT; + return; + } + + //Only update a different revision. + if (Header->UpdateRevision == gUcRevision) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_INVALID_REVISION; + return; + } + + //If no microcode installed, then the revision is 0. + if (gUcRevision != 0) { //Quick check. + if(FindMicrocodeOfStepping(gMcodeFlashStartUpdate, + gMcodeFlashStartUpdate + gMcodeFlashSizeUpdate, + gCpuSignature + ) != NULL) { + Compact = TRUE; //Remove old version. + } + } + if (gFirstEmptyBlk == 0xffff || NewMcodeAlignSize > + (gMcodeFlashStartUpdate + gMcodeFlashSizeUpdate - gMcodeBlkMap[gFirstEmptyBlk].Addr) + ) Compact = TRUE; //Volume is full. + + if (!Compact) { + //Append blocks. + UINT8 *pEmptyBlk = gMcodeBlkMap[gFirstEmptyBlk].Addr; + LoadMicrocodeEachCpu(NewMcode); //Install new microcode. + + //Check to see if new microcode is installed. + if (Header->UpdateRevision != GetInstalledMicrocodeRevision()) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_SECURITY_FAILURE; + return; + } + + FwhWrite(NewMcode, (UINTN)pEmptyBlk, NewMcodeSize); //Currently ignoring status + + InitMcodeBlkMap(); + return; + } + + //***Compact Flash Part*** + + //Currently restrict FLASH_BLOCK_SIZE to 64k or smaller + if (FLASH_BLOCK_SIZE > 64 * 1024) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_NOT_IMPLEMENTED; + } + + //Set up Buffer. + Buffer = (UINT8*)(UINTN)((UINT16)Regs->ECX << 4); + + Status = CheckAddressRange(Buffer, FLASH_BLOCK_SIZE); + if(EFI_ERROR(Status)) return; + + //Find existing microcode of same revision. + McodeUpdateStart = gFirstEmptyBlk == 0xffff ? + gMcodeFlashStartUpdate + gMcodeFlashSizeUpdate : gMcodeBlkMap[gFirstEmptyBlk].Addr; + + OldMcode = FindMicrocodeOfStepping( + gMcodeFlashStartUpdate, + McodeUpdateStart, + gCpuSignature + ); + + //Old Microcode not available to remove? + if (!OldMcode) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_STORAGE_FULL; + return; + } + OldMcodeAlignSize = MICROCODE_ALIGN_SIZE(OldMcode);; + + //Check to see if space big enough for new microcode. + if ((gMcodeFlashStartUpdate + gMcodeFlashSizeUpdate - McodeUpdateStart + OldMcodeAlignSize) < NewMcodeAlignSize) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_STORAGE_FULL; + return; + } + + //Load new microcode, if can't load exit. + LoadMicrocodeEachCpu(NewMcode); //Install new microcode. + if (Header->UpdateRevision != GetInstalledMicrocodeRevision()) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_SECURITY_FAILURE; + return; + } + + //Start compacting at block with Old Microcode to remove. + BlkStart = (UINT8*)((UINTN)OldMcode & ~(FLASH_BLOCK_SIZE - 1)); //Must start at block boundary. + + //Note: When Buffer is full, it will flush to flash. + InitializeFlashBuffer(BlkStart, Buffer); + CopyToFlashBuffer(BlkStart, (UINT32)(OldMcode - BlkStart)); //Copy before old microcode. + + CopyToFlashBuffer(OldMcode + OldMcodeAlignSize, (UINT32)(McodeUpdateStart - (OldMcode + OldMcodeAlignSize))); //Copy after old microcode. + + CopyToFlashBuffer(NewMcode, NewMcodeSize); //Copy new microcode. + + WriteValueToFlashBuffer(0xff, NewMcodeAlignSize - NewMcodeSize); //Fill block space after microcode. + + if (NewMcodeAlignSize < OldMcodeAlignSize) { + WriteValueToFlashBuffer(0xff, OldMcodeAlignSize - NewMcodeAlignSize); //Write 0xff over reclaimed space. Polarity? + } else { + McodeUpdateStart += NewMcodeAlignSize - OldMcodeAlignSize; + } + FillFlashBufferAndFlush(McodeUpdateStart); + + InitMcodeBlkMap(); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MicrocodeUpdateCallback +// +// Description: This notification function is called when an SMM Mode +// is invoked through SMI. This may happen during RT, +// so it must be RT safe. +// Interrupt 15h, function D042h is processed here. +// +// Input: DispatchHandle - EFI Handle +// DispatchContext - Pointer to the EFI_SMM_SW_DISPATCH_CONTEXT +// +// Output: Status code returned to function D042h caller. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID MicrocodeUpdateCallback ( + IN EFI_HANDLE DispatchHandle, + IN EFI_SMM_SW_DISPATCH_CONTEXT *DispatchContext + ) +{ + EFI_STATUS Status; + SMI_UC_DWORD_REGS *Regs; + SW_SMI_CPU_TRIGGER *SwSmiCpuTrigger; + UINTN Cpu = pSmst->CurrentlyExecutingCpu - 1; + UINT8 Function; + UINTN i; + + for (i = 0; i < pSmst->NumberOfTableEntries; ++i) { + if (guidcmp(&pSmst->SmmConfigurationTable[i].VendorGuid,&gSwSmiCpuTriggerGuid) == 0) { + break; + } + } + + //If found table, check for the CPU that caused the software Smi. + if (i != pSmst->NumberOfTableEntries) { + SwSmiCpuTrigger = pSmst->SmmConfigurationTable[i].VendorTable; + Cpu = SwSmiCpuTrigger->Cpu; + } + Regs = (SMI_UC_DWORD_REGS*)(UINTN)(pSmst->CpuSaveState[Cpu].Ia32SaveState.ESI); + + Status = CheckAddressRange((UINT8*)Regs, sizeof(SMI_UC_DWORD_REGS)); + if(EFI_ERROR(Status)) return; + + if ((UINT16)Regs->EAX != 0xD042) return; + + Function = (UINT8)Regs->EBX; //BL + + //Initialize return as successful. + Regs->EFLAGS &= ~CARRY_FLAG; + Regs->EAX &= 0xffff0000; + + if (Function >= MAX_MICROCODE_UPDATE_FUNCTIONS) { + Regs->EFLAGS |= CARRY_FLAG; + *(UINT16*)&Regs->EAX = UC_NOT_IMPLEMENTED; + return; + } + + MicrocodeUpdate[Function](Regs); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InSmmFunction +// +// Description: This function is called from the InitSmmHandler if driver is in SMM. +// +// Input: ImageHandle - Pointer to the loaded image protocol for this driver +// SystemTable - Pointer to the EFI System Table +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS InSmmFunction(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable) +{ + EFI_SMM_SW_DISPATCH_PROTOCOL *pSwDispatch; + EFI_SMM_SW_DISPATCH_CONTEXT SwContext; + EFI_STATUS Status; + EFI_HANDLE Handle; + SMM_HOB *SmmHob; + EFI_GUID SmmHobGuid = SMM_HOB_GUID; + EFI_GUID HobListGuid = HOB_LIST_GUID; + + BOOLEAN IsInit = InitMicrocodeVariables(); + if (!IsInit) return EFI_UNSUPPORTED; + + Status = pBS->LocateProtocol(&gEfiSmmSwDispatchProtocolGuid, NULL, &pSwDispatch); + ASSERT_EFI_ERROR(Status); + + SmmHob = (SMM_HOB*)GetEfiConfigurationTable(pST, &HobListGuid); + if (SmmHob == NULL) return EFI_NOT_FOUND; + + Status = FindNextHobByGuid(&SmmHobGuid,(VOID**)&SmmHob); + if (EFI_ERROR(Status)) return Status; + + gSmmHob = *SmmHob; + + SwContext.SwSmiInputValue = INT15_D042_SWSMI; + + Status = pSwDispatch->Register(pSwDispatch, MicrocodeUpdateCallback, &SwContext, &Handle); + ASSERT_EFI_ERROR(Status); + + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: InitializeMicrocodeSmm +// +// Description: This function registers the INT15 D042 SW SMI handler +// This is the driver entry pOoint. +// +// Input: ImageHandle - Pointer to the loaded image protocol for this driver +// SystemTable - Pointer to the EFI System Table +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS InitializeMicrocodeSmm( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) + +{ + InitAmiLib(ImageHandle, SystemTable); + return InitSmmHandler(ImageHandle, SystemTable, InSmmFunction, NULL); +} + +//************************************************************************* +//************************************************************************* +//** ** +//** (C)Copyright 1987-2011, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//************************************************************************* +//************************************************************************* |