/*++
Copyright (c) 2004-2006 Intel Corporation. All rights reserved
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.
Module Name:
Microcode.c
Abstract:
Utility for working with microcode patch files in the Intel
Platform Innovation Framework for EFI build environment.
--*/
#include <stdio.h>
#include <string.h> // for memset()
#include <ctype.h>
#include <stdlib.h> // for malloc()
#include "EfiUtilityMsgs.h"
#include "Microcode.h"
#define MAX_LINE_LEN 256
#define STATUS_IGNORE 0xA
//
// Structure definition for a microcode header
//
typedef struct {
unsigned int HeaderVersion;
unsigned int PatchId;
unsigned int Date;
unsigned int CpuId;
unsigned int Checksum;
unsigned int LoaderVersion;
unsigned int PlatformId;
unsigned int DataSize; // if 0, then TotalSize = 2048, and TotalSize field is invalid
unsigned int TotalSize; // number of bytes
unsigned int Reserved[3];
} MICROCODE_IMAGE_HEADER;
static
STATUS
MicrocodeReadData (
FILE *InFptr,
unsigned int *Data
);
void
MicrocodeConstructor (
void
)
/*++
Routine Description:
Constructor of module Microcode
Arguments:
None
Returns:
None
--*/
{
}
void
MicrocodeDestructor (
void
)
/*++
Routine Description:
Destructor of module Microcode
Arguments:
None
Returns:
None
--*/
{
}
static
STATUS
MicrocodeReadData (
FILE *InFptr,
unsigned int *Data
)
/*++
Routine Description:
Read a 32-bit microcode data value from a text file and convert to raw binary form.
Arguments:
InFptr - file pointer to input text file
Data - pointer to where to return the data parsed
Returns:
STATUS_SUCCESS - no errors or warnings, Data contains valid information
STATUS_ERROR - errors were encountered
--*/
{
char Line[MAX_LINE_LEN];
char *cptr;
unsigned int ctr;
Line[MAX_LINE_LEN - 1] = 0;
*Data = 0;
if (fgets (Line, MAX_LINE_LEN, InFptr) == NULL) {
return STATUS_ERROR;
}
//
// If it was a binary file, then it may have overwritten our null terminator
//
if (Line[MAX_LINE_LEN - 1] != 0) {
return STATUS_ERROR;
}
// Strip leading white-space characters (except carriage returns) from Line
//
if (isspace(Line[0]) && Line[0] != '\n') {
while (isspace(Line[0])) {
for (ctr = 0; ctr < strlen(Line); ctr++)
if (Line[ctr] != '\n')
Line[ctr] = Line[ctr + 1];
}
}
//
// Look for
// dd 000000001h ; comment
// dd XXXXXXXX
// DD XXXXXXXXX
// DD XXXXXXXXX
//
for (cptr = Line; *cptr && isspace(*cptr); cptr++) {
}
if ((tolower(cptr[0]) == 'd') && (tolower(cptr[1]) == 'd') && isspace (cptr[2])) {
//
// Skip blanks and look for a hex digit
//
cptr += 3;
for (; *cptr && isspace(*cptr); cptr++) {
}
if (isxdigit (*cptr)) {
if (sscanf (cptr, "%X", Data) != 1) {
return STATUS_ERROR;
}
}
return STATUS_SUCCESS;
}
if (strlen(Line) == 1) {
return STATUS_IGNORE;
}
if (tolower(cptr[0]) == ';') {
return STATUS_IGNORE;
}
return STATUS_ERROR;
}
STATUS
MicrocodeParseFile (
char *InFileName,
char *OutFileName
)
/*++
Routine Description:
Parse a microcode text file, and write the binary results to an output file.
Arguments:
InFileName - input text file to parse
OutFileName - output file to write raw binary data from parsed input file
Returns:
STATUS_SUCCESS - no errors or warnings
STATUS_ERROR - errors were encountered
--*/
{
FILE *InFptr;
FILE *OutFptr;
STATUS Status;
MICROCODE_IMAGE_HEADER *Header;
unsigned int Size;
unsigned int Size2;
unsigned int Data;
unsigned int Checksum;
char *Buffer;
char *Ptr;
char *OrigPtr;
unsigned int TotalSize;
Status = STATUS_ERROR;
InFptr = NULL;
OutFptr = NULL;
Buffer = NULL;
//
// Open the input text file
//
if ((InFptr = fopen (InFileName, "r")) == NULL) {
Error (NULL, 0, 0, InFileName, "failed to open input microcode file for reading");
return STATUS_ERROR;
}
//
// Make two passes on the input file. The first pass is to determine how
// much data is in the file so we can allocate a working buffer. Then
// we'll allocate a buffer and re-read the file into the buffer for processing.
//
Size = 0;
do {
Status = MicrocodeReadData (InFptr, &Data);
if (Status == STATUS_SUCCESS) {
Size += sizeof (Data);
}
if (Status == STATUS_IGNORE) {
Status = STATUS_SUCCESS;
}
} while (Status == STATUS_SUCCESS);
//
// Error if no data.
//
if (Size == 0) {
Error (NULL, 0, 0, InFileName, "no parse-able data found in file");
goto Done;
}
if (Size < sizeof (MICROCODE_IMAGE_HEADER)) {
Error (NULL, 0, 0, InFileName, "amount of parse-able data is insufficient to contain a microcode header");
goto Done;
}
//
// Allocate a buffer for the data
//
Buffer = (char *) _malloc (Size);
if (Buffer == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
goto Done;
}
//
// Re-read the file, storing the data into our buffer
//
fseek (InFptr, 0, SEEK_SET);
Ptr = Buffer;
OrigPtr = Ptr;
do {
OrigPtr = Ptr;
Status = MicrocodeReadData (InFptr, &Data);
if (Status == STATUS_SUCCESS) {
*(unsigned int *) Ptr = Data;
Ptr += sizeof (Data);
}
if (Status == STATUS_IGNORE) {
Ptr = OrigPtr;
Status = STATUS_SUCCESS;
}
} while (Status == STATUS_SUCCESS);
//
// Can't do much checking on the header because, per the spec, the
// DataSize field may be 0, which means DataSize = 2000 and TotalSize = 2K,
// and the TotalSize field is invalid (actually missing). Thus we can't
// even verify the Reserved fields are 0.
//
Header = (MICROCODE_IMAGE_HEADER *) Buffer;
if (Header->DataSize == 0) {
TotalSize = 2048;
} else {
TotalSize = Header->TotalSize;
}
if (TotalSize != Size) {
Error (NULL, 0, 0, InFileName, "file contents do not contain expected TotalSize 0x%04X", TotalSize);
goto Done;
}
//
// Checksum the contents
//
Ptr = Buffer;
Checksum = 0;
Size2 = 0;
while (Size2 < Size) {
Checksum += *(unsigned int *) Ptr;
Ptr += 4;
Size2 += 4;
}
if (Checksum != 0) {
Error (NULL, 0, 0, InFileName, "checksum failed on file contents");
goto Done;
}
//
// Open the output file and write the buffer contents
//
if ((OutFptr = fopen (OutFileName, "wb")) == NULL) {
Error (NULL, 0, 0, OutFileName, "failed to open output microcode file for writing");
goto Done;
}
if (fwrite (Buffer, Size, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write microcode data to output file");
goto Done;
}
Status = STATUS_SUCCESS;
Done:
if (Buffer != NULL) {
free (Buffer);
}
if (InFptr != NULL) {
fclose (InFptr);
}
if (OutFptr != NULL) {
fclose (OutFptr);
if (Status == STATUS_ERROR) {
remove (OutFileName);
}
}
return Status;
}