STATIC EFI_STATUS CheckImageHeader ( IN OUT UINTN *ImageHeader ) { MV_FIRMWARE_IMAGE_HEADER *Header; UINT32 HeaderLength, Checksum, ChecksumBackup; Header = (MV_FIRMWARE_IMAGE_HEADER *)ImageHeader; HeaderLength = Header->PrologSize; ChecksumBackup = Header->PrologChecksum; // Compare magic number if (Header->Magic != MAIN_HDR_MAGIC) { Print (L"%s: Bad Image magic 0x%08x != 0x%08x\n", CMD_NAME_STRING, Header->Magic, MAIN_HDR_MAGIC); return EFI_DEVICE_ERROR; } // The checksum field is discarded from calculation Header->PrologChecksum = 0; Checksum = CalculateSum32 ((UINT32 *)Header, HeaderLength); if (Checksum != ChecksumBackup) { Print (L"%s: Bad Image checksum. 0x%x != 0x%x\n", CMD_NAME_STRING, Checksum, ChecksumBackup); return EFI_DEVICE_ERROR; } // Restore checksum backup Header->PrologChecksum = ChecksumBackup; return 0; }
/** Returns the two's complement checksum of all elements in a buffer of 32-bit values. This function first calculates the sum of the 32-bit values in the buffer specified by Buffer and Length. The carry bits in the result of addition are dropped. Then, the two's complement of the sum is returned. If Length is 0, then 0 is returned. If Buffer is NULL, then ASSERT(). If Buffer is not aligned on a 32-bit boundary, then ASSERT(). If Length is not aligned on a 32-bit boundary, then ASSERT(). If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT(). @param Buffer Pointer to the buffer to carry out the checksum operation. @param Length The size, in bytes, of Buffer. @return Checksum The 2's complement checksum of Buffer. **/ UINT32 EFIAPI CalculateCheckSum32 ( IN CONST UINT32 *Buffer, IN UINTN Length ) { UINT32 CheckSum; CheckSum = CalculateSum32 (Buffer, Length); // // Return the checksum based on 2's complement. // return (UINT32) ((UINT32)(-1) - CheckSum + 1); }
/** Detect whether specified processor can find matching microcode patch and load it. **/ VOID MicrocodeDetect ( VOID ) { UINT64 MicrocodePatchAddress; UINT64 MicrocodePatchRegionSize; UINT32 ExtendedTableLength; UINT32 ExtendedTableCount; EFI_CPU_MICROCODE_EXTENDED_TABLE *ExtendedTable; EFI_CPU_MICROCODE_EXTENDED_TABLE_HEADER *ExtendedTableHeader; EFI_CPU_MICROCODE_HEADER *MicrocodeEntryPoint; UINTN MicrocodeEnd; UINTN Index; UINT8 PlatformId; UINT32 RegEax; UINT32 LatestRevision; UINTN TotalSize; UINT32 CheckSum32; BOOLEAN CorrectMicrocode; INT32 CurrentSignature; MICROCODE_INFO MicrocodeInfo; ZeroMem (&MicrocodeInfo, sizeof (MICROCODE_INFO)); MicrocodePatchAddress = PcdGet64 (PcdCpuMicrocodePatchAddress); MicrocodePatchRegionSize = PcdGet64 (PcdCpuMicrocodePatchRegionSize); if (MicrocodePatchRegionSize == 0) { // // There is no microcode patches // return; } ExtendedTableLength = 0; // // Here data of CPUID leafs have not been collected into context buffer, so // GetProcessorCpuid() cannot be used here to retrieve CPUID data. // AsmCpuid (CPUID_VERSION_INFO, &RegEax, NULL, NULL, NULL); // // The index of platform information resides in bits 50:52 of MSR IA32_PLATFORM_ID // PlatformId = (UINT8) AsmMsrBitFieldRead64 (EFI_MSR_IA32_PLATFORM_ID, 50, 52); LatestRevision = 0; MicrocodeEnd = (UINTN) (MicrocodePatchAddress + MicrocodePatchRegionSize); MicrocodeEntryPoint = (EFI_CPU_MICROCODE_HEADER *) (UINTN) MicrocodePatchAddress; do { // // Check if the microcode is for the Cpu and the version is newer // and the update can be processed on the platform // CorrectMicrocode = FALSE; if (MicrocodeEntryPoint->HeaderVersion == 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->ProcessorId == RegEax && MicrocodeEntryPoint->UpdateRevision > LatestRevision && (MicrocodeEntryPoint->ProcessorFlags & (1 << PlatformId)) ) { if (MicrocodeEntryPoint->DataSize == 0) { CheckSum32 = CalculateSum32 ((UINT32 *)MicrocodeEntryPoint, 2048); } else { CheckSum32 = CalculateSum32 ((UINT32 *)MicrocodeEntryPoint, MicrocodeEntryPoint->DataSize + sizeof(EFI_CPU_MICROCODE_HEADER)); } if (CheckSum32 == 0) { CorrectMicrocode = TRUE; } } else if ((MicrocodeEntryPoint->DataSize != 0) && (MicrocodeEntryPoint->UpdateRevision > LatestRevision)) { ExtendedTableLength = MicrocodeEntryPoint->TotalSize - (MicrocodeEntryPoint->DataSize + sizeof (EFI_CPU_MICROCODE_HEADER)); if (ExtendedTableLength != 0) { // // Extended Table exist, check if the CPU in support list // ExtendedTableHeader = (EFI_CPU_MICROCODE_EXTENDED_TABLE_HEADER *)((UINT8 *)(MicrocodeEntryPoint) + MicrocodeEntryPoint->DataSize + sizeof (EFI_CPU_MICROCODE_HEADER)); // // Calculate Extended Checksum // if ((ExtendedTableLength % 4) == 0) { CheckSum32 = CalculateSum32 ((UINT32 *)ExtendedTableHeader, ExtendedTableLength); if (CheckSum32 == 0) { // // Checksum correct // ExtendedTableCount = ExtendedTableHeader->ExtendedSignatureCount; ExtendedTable = (EFI_CPU_MICROCODE_EXTENDED_TABLE *)(ExtendedTableHeader + 1); for (Index = 0; Index < ExtendedTableCount; Index ++) { CheckSum32 = CalculateSum32 ((UINT32 *)ExtendedTable, sizeof(EFI_CPU_MICROCODE_EXTENDED_TABLE)); if (CheckSum32 == 0) { // // Verify Header // if ((ExtendedTable->ProcessorSignature == RegEax) && (ExtendedTable->ProcessorFlag & (1 << PlatformId)) ) { // // Find one // CorrectMicrocode = TRUE; break; } } ExtendedTable ++; } } } } } } 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_1KB padding data to // find the next possible microcode patch header. // MicrocodeEntryPoint = (EFI_CPU_MICROCODE_HEADER *) (((UINTN) MicrocodeEntryPoint) + SIZE_1KB); continue; } // // Get the next patch. // if (MicrocodeEntryPoint->DataSize == 0) { TotalSize = 2048; } else { TotalSize = MicrocodeEntryPoint->TotalSize; } if (CorrectMicrocode) { LatestRevision = MicrocodeEntryPoint->UpdateRevision; MicrocodeInfo.MicrocodeData = (VOID *)((UINTN)MicrocodeEntryPoint + sizeof (EFI_CPU_MICROCODE_HEADER)); MicrocodeInfo.MicrocodeSize = TotalSize; MicrocodeInfo.ProcessorId = RegEax; } MicrocodeEntryPoint = (EFI_CPU_MICROCODE_HEADER *) (((UINTN) MicrocodeEntryPoint) + TotalSize); } while (((UINTN) MicrocodeEntryPoint < MicrocodeEnd)); if (LatestRevision > 0) { // // Get microcode update signature of currently loaded microcode update // CurrentSignature = GetCurrentMicrocodeSignature (); // // If no microcode update has been loaded, then trigger microcode load. // if (CurrentSignature == 0) { AsmWriteMsr64 ( EFI_MSR_IA32_BIOS_UPDT_TRIG, (UINT64) (UINTN) MicrocodeInfo.MicrocodeData ); MicrocodeInfo.Load = TRUE; } else { MicrocodeInfo.Load = FALSE; } } }