xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Universal/FirmwareVolume/FtwLiteRuntimeDxe/FtwWorkSpace.c

535 lines
16 KiB
C
Raw Blame History

/** @file
;******************************************************************************
;* Copyright (c) 2012 - 2019, 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.
;*
;******************************************************************************
*/
#include "FtwLite.h"
/**
Check to see if it is a valid work space.
@param WorkingHeader Pointer of working block header.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
**/
BOOLEAN
IsValidWorkSpace (
IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader
)
{
EFI_STATUS Status;
EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER WorkingBlockHeader;
ASSERT (WorkingHeader != NULL);
if (WorkingHeader->WorkingBlockValid != FTW_VALID_STATE) {
return FALSE;
}
//
// Check signature with gEfiSystemNvDataFvGuid
//
if (!CompareGuid (&gEfiSystemNvDataFvGuid, &WorkingHeader->Signature)) {
return FALSE;
}
//
// Check the CRC of header
//
CopyMem (
&WorkingBlockHeader,
WorkingHeader,
sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)
);
//
// Filter out the Crc and State fields
//
SetMem (&WorkingBlockHeader.Crc, sizeof (UINT32), FTW_ERASED_BYTE);
WorkingBlockHeader.WorkingBlockValid = FTW_ERASE_POLARITY;
WorkingBlockHeader.WorkingBlockInvalid = FTW_ERASE_POLARITY;
//
// Calculate the Crc of woking block header
//
Status = RuntimeDriverCalculateCrc32 (
(UINT8 *) &WorkingBlockHeader,
sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),
&WorkingBlockHeader.Crc
);
if (WorkingBlockHeader.Crc != WorkingHeader->Crc) {
DEBUG ((mFtwLiteError, "FtwLite: Work block header CRC check error\n"));
return FALSE;
}
return TRUE;
}
/**
Initialize a work space when there is no work space.
@param WorkingHeader Pointer of working block header.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
InitWorkSpaceHeader (
IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader
)
{
EFI_STATUS Status;
ASSERT (WorkingHeader != NULL);
//
// Here using gEfiSystemNvDataFvGuid as the signature.
//
CopyMem (
&WorkingHeader->Signature,
&gEfiSystemNvDataFvGuid,
sizeof (EFI_GUID)
);
WorkingHeader->WriteQueueSize = (UINTN) FdmGetNAtSize (&gH2OFlashMapRegionFtwStateGuid, 1) - sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER);
//
// Crc is calculated with all the fields except Crc and STATE
//
WorkingHeader->WorkingBlockValid = FTW_ERASE_POLARITY;
WorkingHeader->WorkingBlockInvalid = FTW_ERASE_POLARITY;
SetMem (&WorkingHeader->Crc, sizeof (UINT32), FTW_ERASED_BYTE);
//
// Calculate the CRC value
//
Status = RuntimeDriverCalculateCrc32 (
(UINT8 *) WorkingHeader,
sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),
&WorkingHeader->Crc
);
ASSERT_EFI_ERROR (Status);
//
// Restore the WorkingBlockValid flag to VALID state
//
WorkingHeader->WorkingBlockValid = FTW_VALID_STATE;
WorkingHeader->WorkingBlockInvalid = FTW_INVALID_STATE;
return EFI_SUCCESS;
}
/**
Update a bit of state on a block device. The location of the bit is calculated by the
(Lba, Offset, bit). Here bit is determined by the the name of a certain bit.
@param FtwLiteDevice The private data of FTW_LITE driver.
@param FvBlock FVB Protocol interface to access SrcBlock and DestBlock.
@param Lba Lba of a block.
@param Offset Offset on the Lba.
@param Address The Address of FvState.
@param NewBit New value that will override the old value if it can be change.
@retval EFI_SUCCESS A state bit has been updated successfully
@retval EFI_ABORTED Read block fail.
@return Others Access block device error.
**/
EFI_STATUS
FtwUpdateFvState (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,
IN EFI_LBA Lba,
IN UINTN Offset,
IN UINTN Address,
IN UINT8 NewBit
)
{
EFI_STATUS Status;
UINT8 State;
UINTN Length;
UINT8 ReadState;
UINTN TryWritetimes;
BOOLEAN WriteSuccess;
//
// Read state from device, assume State is only one byte.
//
Length = sizeof (UINT8);
if (mSmst == NULL) {
Lba += Offset / FtwLiteDevice->SizeOfSpareBlock;
Offset = Offset % FtwLiteDevice->SizeOfSpareBlock;
Status = FvBlock->Read (FvBlock, Lba, Offset, &Length, &State);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
} else {
CopyMem (&State, (UINT8 *) Address, Length);
}
State ^= FTW_POLARITY_REVERT;
State |= NewBit;
State ^= FTW_POLARITY_REVERT;
WriteSuccess = FALSE;
TryWritetimes = 0;
Status = EFI_ABORTED;
//
// Start try write state to device and using do-while to make sure
// at least write state once.
//
do {
//
// Write state back to device
//
Length = sizeof (UINT8);
if (mSmst == NULL) {
Status = FvBlock->Write (FvBlock, Lba, Offset, &Length, &State);
} else {
Status = FtwLiteDevice->SmmFwbServices->Write (
FtwLiteDevice->SmmFwbServices,
(UINTN)Address,
&Length,
&State
);
}
Length = sizeof (UINT8);
if (mSmst == NULL) {
Status = FvBlock->Read (FvBlock, Lba, Offset, &Length, &ReadState);
} else {
CopyMem (&ReadState, (UINT8 *) Address, Length);
}
//
// Check write data is whther correct
//
WriteSuccess = (ReadState == State) ? TRUE : FALSE;
TryWritetimes++;
} while (!WriteSuccess && TryWritetimes < FTW_MAX_TRY_ACCESS_FVB_TIMES);
//
// if write failed, set status as EFI_ABORT
//
if (!WriteSuccess) {
Status = EFI_ABORTED;
}
return Status;
}
/**
Get the last Write record pointer. The last record is the record whose 'complete' state hasn't
been set. After all, this header may be a EMPTY header entry for next Allocate.
@param FtwLiteDevice Private data of this driver.
@param FtwLastRecord Pointer to retrieve the last write record.
@retval EFI_SUCCESS Get the last write record successfully.
@retval EFI_ABORTED The FTW work space is damaged.
**/
EFI_STATUS
FtwGetLastRecord (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
OUT EFI_FTW_LITE_RECORD **FtwLastRecord
)
{
EFI_FTW_LITE_RECORD *Record;
Record = (EFI_FTW_LITE_RECORD *) (FtwLiteDevice->FtwWorkSpaceHeader + 1);
while (Record->WriteCompleted == FTW_VALID_STATE) {
//
// If Offset exceed the FTW work space boudary, return error.
//
if ((UINTN) ((UINT8 *) Record - FtwLiteDevice->FtwWorkSpace) > FtwLiteDevice->FtwWorkSpaceSize) {
return EFI_ABORTED;
}
Record++;
}
//
// Last write record is found
//
*FtwLastRecord = Record;
return EFI_SUCCESS;
}
/**
Read from working block to refresh the work space in memory.
@param FtwLiteDevice Point to private data of FTW driver.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
WorkSpaceRefresh (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice
)
{
EFI_STATUS Status;
UINTN Length;
UINTN Offset;
EFI_FTW_LITE_RECORD *Record;
UINTN Index;
//
// Initialize WorkSpace as FTW_ERASED_BYTE
//
SetMem (FtwLiteDevice->FtwWorkSpace, FtwLiteDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE);
//
// Read from working block
//
if (mSmst == NULL) {
if (FtwLiteDevice->NumberOfFtwWorkBlock != 0) {
for (Index = 0; Index < FtwLiteDevice->NumberOfFtwWorkBlock; Index++) {
Length = FtwLiteDevice->FtwWorkSpaceSize / FtwLiteDevice->NumberOfFtwWorkBlock;
Status = FtwLiteDevice->FtwFvBlock->Read (
FtwLiteDevice->FtwFvBlock,
FtwLiteDevice->FtwWorkSpaceLba + Index,
FtwLiteDevice->FtwWorkSpaceBase,
&Length,
FtwLiteDevice->FtwWorkSpace + (Length * Index)
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
}
} else {
Length = FtwLiteDevice->FtwWorkSpaceSize;
Status = FtwLiteDevice->FtwFvBlock->Read (
FtwLiteDevice->FtwFvBlock,
FtwLiteDevice->FtwWorkSpaceLba,
FtwLiteDevice->FtwWorkSpaceBase,
&Length,
FtwLiteDevice->FtwWorkSpace
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
}
} else {
Length = FtwLiteDevice->FtwWorkSpaceSize;
CopyMem (FtwLiteDevice->FtwWorkSpace, (UINT8 *) (UINTN) FtwLiteDevice->WorkSpaceAddress, Length);
}
//
// Refresh the FtwLastRecord
//
Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);
Record = FtwLiteDevice->FtwLastRecord;
Offset = (UINTN) (UINT8 *) Record - (UINTN) FtwLiteDevice->FtwWorkSpace;
//
// IF work space has error or Record is out of the workspace limit, THEN
// call reclaim.
//
if (EFI_ERROR (Status) || (Offset + WRITE_TOTAL_SIZE >= FtwLiteDevice->FtwWorkSpaceSize)) {
//
// reclaim work space in working block.
//
Status = FtwReclaimWorkSpace (FtwLiteDevice);
if (EFI_ERROR (Status)) {
DEBUG ((mFtwLiteError, "FtwLite: Reclaim workspace - %r\n", Status));
return EFI_ABORTED;
}
}
return EFI_SUCCESS;
}
/**
Reclaim the work space. Get rid of all the completed write records and write records in
the Fault Tolerant work space.
@param FtwLiteDevice Point to private data of FTW driver.
@param FtwSpaceBuffer Buffer to contain the reclaimed clean data.
@param BufferSize Size of the FtwSpaceBuffer.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_BUFFER_TOO_SMALL The FtwSpaceBuffer is too small.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
CleanupWorkSpace (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN OUT UINT8 *FtwSpaceBuffer,
IN UINTN BufferSize
)
{
UINTN Length;
EFI_FTW_LITE_RECORD *Record;
//
// To check if the buffer is large enough
//
Length = FtwLiteDevice->FtwWorkSpaceSize;
if (BufferSize < Length) {
return EFI_BUFFER_TOO_SMALL;
}
//
// Clear the content of buffer that will save the new work space data
//
SetMem (FtwSpaceBuffer, Length, FTW_ERASED_BYTE);
//
// Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer
//
CopyMem (
FtwSpaceBuffer,
FtwLiteDevice->FtwWorkSpaceHeader,
sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)
);
//
// Get the last record
//
Record = FtwLiteDevice->FtwLastRecord;
if ((Record != NULL) && (Record->WriteAllocated == FTW_VALID_STATE) && (Record->WriteCompleted != FTW_VALID_STATE)) {
CopyMem (
(UINT8 *) FtwSpaceBuffer + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),
Record,
WRITE_TOTAL_SIZE
);
}
return EFI_SUCCESS;
}
/**
Reclaim the work space on the working block.
@param FtwLiteDevice Point to private data of FTW driver.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_OUT_OF_RESOURCES Allocate memory error.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
FtwReclaimWorkSpace (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice
)
{
EFI_STATUS Status;
UINT8 *TempBuffer;
UINTN TempBufferSize;
UINT8 *Ptr;
UINTN SpareBufferSize;
UINT8 *SpareBuffer;
EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader;
DEBUG ((mFtwLiteError, "FtwLite: start to reclaim work space\n"));
//
// Read all original data from working block to a memory buffer
//
TempBufferSize = FtwLiteDevice->SpareAreaLength;
TempBuffer = FtwAllocateZeroBuffer (FtwLiteDevice, TempBufferSize);
if (TempBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
ZeroMem (TempBuffer, TempBufferSize);
Ptr = TempBuffer;
Status = FtwLiteReadWorkBlock (FtwLiteDevice, TempBuffer);
if (EFI_ERROR (Status)) {
FtwFreePool (FtwLiteDevice, (VOID **)&TempBuffer);
return EFI_ABORTED;
}
//
// Clean up the workspace, remove all the completed records.
//
Ptr = TempBuffer +
((UINTN) (FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba)) *
FtwLiteDevice->SizeOfSpareBlock +
FtwLiteDevice->FtwWorkSpaceBase;
Status = CleanupWorkSpace (
FtwLiteDevice,
Ptr,
FtwLiteDevice->FtwWorkSpaceSize
);
CopyMem (
FtwLiteDevice->FtwWorkSpace,
Ptr,
FtwLiteDevice->FtwWorkSpaceSize
);
Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);
//
// Set the WorkingBlockValid and WorkingBlockInvalid as INVALID
//
WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) Ptr;
WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE;
WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE;
//
// Try to keep the content of spare block
// Save spare block into a spare backup memory buffer (Sparebuffer)
//
SpareBufferSize = FtwLiteDevice->SpareAreaLength;
SpareBuffer = FtwAllocateZeroBuffer (FtwLiteDevice, SpareBufferSize);
if (SpareBuffer == NULL) {
FtwFreePool (FtwLiteDevice, (VOID **)&TempBuffer);
return EFI_OUT_OF_RESOURCES;
}
Ptr = SpareBuffer;
Status = FtwLiteReadSpareBlock (FtwLiteDevice, SpareBuffer);
//
// Write the memory buffer to spare block
//
Status = FtwWriteSpareBlock (FtwLiteDevice, TempBuffer, SpareBufferSize, FTW_MAX_TRY_ACCESS_FVB_TIMES);
if (EFI_ERROR (Status)) {
FtwFreePool (FtwLiteDevice, (VOID **)&TempBuffer);
FtwFreePool (FtwLiteDevice, (VOID **)&SpareBuffer);
return EFI_ABORTED;
}
FtwFreePool (FtwLiteDevice, (VOID **)&TempBuffer);
//
// Write the spare block to working block
//
Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice);
if (EFI_ERROR (Status)) {
FtwFreePool (FtwLiteDevice, (VOID **)&SpareBuffer);
return Status;
}
//
// Restore spare backup buffer into spare block , if no failure happened during FtwWrite.
//
Status = FtwWriteSpareBlock (FtwLiteDevice, SpareBuffer, SpareBufferSize, FTW_MAX_TRY_ACCESS_FVB_TIMES);
if (EFI_ERROR (Status)) {
FtwFreePool (FtwLiteDevice, (VOID **)&SpareBuffer);
return EFI_ABORTED;
}
FtwFreePool (FtwLiteDevice, (VOID **)&SpareBuffer);
DEBUG ((mFtwLiteError, "FtwLite: reclaim work space success\n"));
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink