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/FtwLite.h

710 lines
23 KiB
C
Raw Blame History

/** @file
This is a simple fault tolerant write driver, based on PlatformFd library.
And it only supports write BufferSize <= SpareAreaLength.
This boot service only protocol provides fault tolerant write capability for
block devices. The protocol has internal non-volatile intermediate storage
of the data and private information. It should be able to recover
automatically from a critical fault, such as power failure.
;******************************************************************************
;* Copyright (c) 2012 - 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.
;*
;******************************************************************************
*/
#ifndef _EFI_FAULT_TOLERANT_WRITE_LITE_H_
#define _EFI_FAULT_TOLERANT_WRITE_LITE_H_
#include <PiSmm.h>
#include <Protocol/SmmBase2.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Protocol/FaultTolerantWriteLite.h>
#include <Protocol/SmmFwBlockService.h>
#include <Protocol/SmmFtw.h>
#include <Protocol/FirmwareVolume2.h>
#include <Uefi.h>
#include <Library/PcdLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/ImageRelocationLib.h>
#include <Library/FlashRegionLib.h>
#include <Guid/SystemNvDataGuid.h>
#include <Guid/AuthenticatedVariableFormat.h>
#include <Guid/EventGroup.h>
//
// Flash erase polarity is 1
//
#define FTW_ERASE_POLARITY 1
#define FTW_VALID_STATE 0
#define FTW_INVALID_STATE 1
#define FTW_ERASED_BYTE ((UINT8) (255))
#define FTW_POLARITY_REVERT ((UINT8) (255))
//
// MACRO for FTW header and record
//
#define FTW_LITE_RECORD_SIZE (sizeof (EFI_FTW_LITE_RECORD))
#define WRITE_TOTAL_SIZE FTW_LITE_RECORD_SIZE
#define FTW_MAX_TRY_ACCESS_FVB_TIMES 0x02
#define MAX_MEMORY_NODE 0x06
#define FTW_LITE_DEVICE_SIGNATURE SIGNATURE_32 ('F', 'T', 'W', 'L')
#define FTW_LITE_CONTEXT_FROM_THIS(a) CR (a, EFI_FTW_LITE_DEVICE, FtwLiteInstance, FTW_LITE_DEVICE_SIGNATURE)
#define SMM_FTW_LITE_CONTEXT_FROM_THIS(a) CR (a, EFI_FTW_LITE_DEVICE, SmmFtwProtocol, FTW_LITE_DEVICE_SIGNATURE)
#define EFI_D_FTW_LITE EFI_D_ERROR
#define EFI_D_FTW_INFO EFI_D_INFO
#define EFI_FREE_POOL(Addr) \
{ mSmst ? mSmst->SmmFreePool((VOID*) (Addr)) : gBS->FreePool ((VOID *) (Addr)); \
Addr = NULL;}
typedef struct {
UINT8 WriteAllocated : 1;
UINT8 SpareCompleted : 1;
UINT8 WriteCompleted : 1;
UINT8 Reserved : 5;
#define WRITE_ALLOCATED 0x1
#define SPARE_COMPLETED 0x2
#define WRITE_COMPLETED 0x4
EFI_DEV_PATH DevPath;
EFI_LBA Lba;
UINTN Offset;
UINTN NumBytes;
//
// UINTN SpareAreaOffset;
//
} EFI_FTW_LITE_RECORD;
typedef struct {
BOOLEAN Used;
UINTN BufferSize;
VOID *Buffer;
VOID *PhysicalBuffer;
} EFI_FTW_LITE_BUFFER;
//
// EFI Fault tolerant protocol private data structure
//
typedef struct {
UINTN Signature;
EFI_HANDLE Handle;
EFI_FTW_LITE_PROTOCOL FtwLiteInstance;
EFI_SMM_FTW_PROTOCOL SmmFtwProtocol;
EFI_SMM_FW_BLOCK_SERVICE_PROTOCOL *SmmFwbServices;
EFI_PHYSICAL_ADDRESS WorkSpaceFvBaseAddr;
EFI_PHYSICAL_ADDRESS SpareAreaFvBaseAddr;
EFI_PHYSICAL_ADDRESS WorkBlockAddr;
EFI_PHYSICAL_ADDRESS WorkSpaceAddress;
UINTN WorkSpaceLength;
EFI_PHYSICAL_ADDRESS SpareAreaAddress;
UINTN SpareAreaLength;
UINTN NumberOfSpareBlock; // Number of the blocks in spare block
UINTN SizeOfSpareBlock; // Block size in bytes of the blocks in spare block
EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *FtwWorkSpaceHeader;
EFI_FTW_LITE_RECORD *FtwLastRecord;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FtwFvBlock; // FVB of working block
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FtwBackupFvb; // FVB of spare block
EFI_LBA FtwSpareLba;
EFI_LBA FtwWorkBlockLba; // Start LBA of working block
EFI_LBA FtwWorkSpaceLba; // Start LBA of working space
UINTN FtwWorkSpaceBase; // Offset from LBA start addr
UINTN NumberOfFtwWorkBlock; // Number of the blocks in Ftw work block
UINTN FtwWorkSpaceSize;
EFI_FTW_LITE_BUFFER *ReclaimMemory;
UINT8 *FtwWorkSpace;
//
// Following a buffer of FtwWorkSpace[FTW_WORK_SPACE_SIZE],
// Allocated with EFI_FTW_LITE_DEVICE.
//
} EFI_FTW_LITE_DEVICE;
/**
This function is the entry point of the Fault Tolerant Write driver.
@param ImageHandle EFI_HANDLE: A handle for the image that is initializing this driver.
@param SystemTable EFI_SYSTEM_TABLE: A pointer to the EFI system table.
@retval EFI_SUCCESS FTW has finished the initialization
@retval EFI_ABORTED FTW initialization error.
**/
EFI_STATUS
EFIAPI
InitializeFtwLite (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
/**
Starts a target block update. This function will record data about write in fault tolerant
storage and will complete the write in a recoverable manner, ensuring at all times that
either the original contents or the modified contents are available.
@param This Calling context.
@param FvbHandle The handle of FVB protocol that provides services for reading,
writing, and erasing the target block.
@param Lba The logical block address of the target block.
@param Offset The offset within the target block to place the data.
@param NumBytes The number of bytes to write to the target block.
@param Buffer The data to write.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_BAD_BUFFER_SIZE The write would span a target block, which is not a valid action.
@retval EFI_ACCESS_DENIED No writes have been allocated.
@retval EFI_NOT_FOUND Cannot find FVB by handle.
@retval EFI_OUT_OF_RESOURCES Cannot allocate memory.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
EFIAPI
FtwLiteWrite (
IN EFI_FTW_LITE_PROTOCOL *This,
IN EFI_HANDLE FvbHandle,
IN EFI_LBA Lba,
IN UINTN Offset,
IN UINTN *NumBytes,
IN VOID *Buffer
);
/**
Write a record with fault tolerant mannaer. Since the content has already backuped in
spare block, the write is guaranteed to be completed with fault tolerant manner.
@param FtwLiteDevice The private data of FTW_LITE driver.
@param Fvb The FVB protocol that provides services for reading, writing,
and erasing the target block.
@param FvBaseAddr Frimware volume base address.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
FtwWriteRecord (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb,
IN EFI_PHYSICAL_ADDRESS FvBaseAddr
);
/**
To Erase one block. The size is FTW_BLOCK_SIZE.
@param FtwLiteDevice Calling context
@param FvBlock FVB Protocol interface
@param FvBaseAddr The Firmware Volume BaseAddress of target block.
@param Lba Lba of the firmware block
@retval EFI_SUCCESS Block LBA is Erased successfully.
@retval EFI_ABORTED Error occurs.
**/
EFI_STATUS
FtwEraseBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,
IN EFI_PHYSICAL_ADDRESS FvBaseAddr,
EFI_LBA Lba
);
/**
Function uses to erase whole spare block.
@param FtwLiteDevice Calling context
@retval EFI_SUCCESS Whole spare block is Erased successfully.
@retval EFI_ABORTED Error occurs.
**/
EFI_STATUS
FtwEraseSpareBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice
);
/**
Write target block and check the data which write to target block is correct.
@param FtwLiteDevice Calling context.
@param FvBlock FVB Protocol interface to access target block.
@param FvBaseAddr The Firmware Volume BaseAddress of target block.
@param StartLba Lba of the target block.
@param WriteBuffer Write Buffer.
@param WriteLength The size of write data.
@param MaxTryWriteTimes The maximum trying to write times.
@retval EFI_SUCCESS Write data to working block success.
@retval EFI_OUT_OF_RESOURCE Allocate memory error.
@retval EFI_ABORTED Erase, write, or read error.
@retval EFI_DEVICE_ERROR Cannont write data to spare block.
@retval EFI_INVALID_PARAMETER Any input value is invalid.
**/
EFI_STATUS
WriteTargetBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,
IN EFI_PHYSICAL_ADDRESS FvBaseAddr,
IN EFI_LBA StartLba,
IN UINT8 *WriteBuffer,
IN UINTN WriteLength,
IN UINTN MaxTryWriteTimes
);
/**
Clear first FV header size to 0 in spare block.
@param[in] FtwLiteDevice Pointer to EFI_FTW_LITE_DEVICE.
@retval EFI_SUCCESS Write data to working block success.
@retval EFI_DEVICE_ERROR Cannont write data to spare block.
**/
EFI_STATUS
FtwClearSpareHeader (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice
);
/**
Write spare block and check the data which write to spare block is correct.
@param FtwLiteDevice Calling context.
@param WriteBuffer Write Buffer.
@param WriteLength The size of write data.
@param TryWriteTimes The maximum trying to write times.
@retval EFI_SUCCESS Write data to spare block success.
@retval EFI_OUT_OF_RESOURCE The input value is invalid.
@retval EFI_ABORTED Write data to spare block failed.
**/
EFI_STATUS
FtwWriteSpareBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN UINT8 *WriteBuffer,
IN UINTN WriteLength,
IN UINTN MaxTryWriteTimes
);
/**
Write working block and check the data which write to working block is correct.
@param FtwLiteDevice Calling context.
@param WriteBuffer Write Buffer.
@param WriteLength The size of write data.
@param TryWriteTimes The maximum trying to write times.
@retval EFI_SUCCESS Write data to working block success.
@retval EFI_OUT_OF_RESOURCE Allocate memory error.
@retval EFI_ABORTED Erase, write, or read error.
@retval EFI_DEVICE_ERROR Cannont write data to working block.
@retval EFI_INVALID_PARAMETER Any input value is invalid
**/
EFI_STATUS
FtwWriteWorkingBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN UINT8 *WriteBuffer,
IN UINTN WriteLength,
IN UINTN MaxTryWriteTimes
);
/**
Get firmware block by address.
@param FvBlockHandle Address specified the block.
@param FvBlock The block caller wanted.
@retval EFI_SUCCESS Get Fvb protocol successful.
@retval EFI_NOT_FOUND Block not found
**/
EFI_STATUS
GetFvbByAddress (
IN EFI_PHYSICAL_ADDRESS Address,
OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock
);
/**
According physical address or LBA to check this address is whether
located in working block.
@param FtwLiteDevice Calling context.
@param FvBlock Fvb protocol instance.
@param Lba input LBA for proteced mode use.
@param Address input target address for SMM mode use.
@retval TRUE This address or LBA is located in working block
@retval FALSE This address or LBA isn't located in working block
**/
BOOLEAN
IsInWorkingBlock (
EFI_FTW_LITE_DEVICE *FtwLiteDevice,
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,
EFI_LBA Lba,
EFI_PHYSICAL_ADDRESS Address
);
/**
Copy the content of spare block to a target block. Size is FTW_BLOCK_SIZE. Spare block
is accessed by FTW backup FVB protocol interface. LBA is FtwLiteDevice->FtwSpareLba.
Target block is accessed by FvBlock protocol interface. LBA is Lba.
@param FtwLiteDevice The private data of FTW_LITE driver.
@param FvBlock FVB Protocol interface to access target block.
@param FvBaseAddr Frimware volume base address.
@param Lba Lba of the target block.
@retval EFI_SUCCESS Spare block content is copied to target block.
@retval EFI_INVALID_PARAMETER Input parameter error.
@retval EFI_OUT_OF_RESOURCES Allocate memory error.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
FlushSpareBlockToTargetBlock (
EFI_FTW_LITE_DEVICE *FtwLiteDevice,
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,
IN EFI_PHYSICAL_ADDRESS FvBaseAddr,
EFI_LBA Lba
);
/**
Copy the content of spare block to working block. Size is FTW_BLOCK_SIZE. Spare block is
accessed by FTW backup FVB protocol interface. LBA is FtwLiteDevice->FtwSpareLba. Working
block is accessed by FTW working FVB protocol interface. LBA is FtwLiteDevice->FtwWorkBlockLba.
@param FtwLiteDevice The private data of FTW_LITE driver.
@retval EFI_SUCCESS Spare block content is copied to target block.
@retval EFI_OUT_OF_RESOURCES Allocate memory error.
@retval EFI_ABORTED The function could not complete successfully.
Notes:
Since the working block header is important when FTW initializes, the state of the operation
should be handled carefully. The Crc value is calculated without STATE element.
**/
EFI_STATUS
FlushSpareBlockToWorkingBlock (
EFI_FTW_LITE_DEVICE *FtwLiteDevice
);
/**
Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. Spare block is accessed
by FTW backup FVB protocol interface. LBA is FtwLiteDevice->FtwSpareLba. Boot block is accessed
by BootFvb protocol interface. LBA is 0.
@param FtwLiteDevice The private data of FTW_LITE driver.
@retval EFI_SUCCESS Spare block content is copied to boot block.
@retval EFI_INVALID_PARAMETER Input parameter error.
@retval EFI_OUT_OF_RESOURCES Allocate memory error.
@retval EFI_ABORTED The function could not complete successfully.
**/
EFI_STATUS
FlushSpareBlockToBootBlock (
EFI_FTW_LITE_DEVICE *FtwLiteDevice
);
/**
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
);
/**
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
);
/**
Check whether a flash buffer is erased.
@param Polarity All 1 or all 0.
@param Buffer Buffer to check.
@param BufferSize Size of the buffer.
@retval TRUE This is an erased buffer.
@retval FALSE This isn't an erased buffer.
**/
BOOLEAN
IsErasedFlashBuffer (
IN BOOLEAN Polarity,
IN UINT8 *Buffer,
IN UINTN BufferSize
);
/**
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
);
/**
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
);
/**
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
);
/**
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 *BlockBuffer,
IN UINTN BufferSize
);
/**
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
);
/**
Read all data from whole work block.
@param FtwLiteDevice Point to private data of FTW driver.
@param Buffer Buffer to save work block data.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
@retval EFI_INVALID_PARAMETER Some input parameter is invalid.
**/
EFI_STATUS
FtwLiteReadWorkBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
OUT UINT8 *Buffer
);
/**
Read all data from whole work block.
@param FtwLiteDevice Point to private data of FTW driver.
@param Buffer Buffer to save work block data.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED The function could not complete successfully.
@retval EFI_INVALID_PARAMETER Some input parameter is invalid.
**/
EFI_STATUS
FtwLiteReadSpareBlock (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
OUT UINT8 *Buffer
);
/**
Initialize CRC32 table.
**/
VOID
RuntimeDriverInitializeCrc32Table (
VOID
);
/**
Calculate CRC32 for target data.
@param Data The target data.
@param DataSize The target data size.
@param CrcOut The CRC32 for target data.
@retval EFI_SUCCESS The CRC32 for target data is calculated successfully.
@retval EFI_INVALID_PARAMETER Some parameter is not valid, so the CRC32 is not calculated.
**/
EFI_STATUS
EFIAPI
RuntimeDriverCalculateCrc32 (
IN VOID *Data,
IN UINTN DataSize,
OUT UINT32 *CrcOut
);
/**
This function uses to allocate runtimeservicesdata memory in protected mode before before exit
boot services event.
Size - The size of buffer to allocate
Returns:
NULL - Buffer unsuccessfully allocated.
Other - Buffer successfully allocated.
**/
VOID *
AllocateZeroRuntimeDataBuffer (
IN UINTN Size
);
/**
According to system mode to allocate pool. Allocate pool from pre-allocate RuntimeServicesData in protect mode.
Allocate EfiRuntimeServicesData (actually this memory is located in the range of SMM RAM)
in SMM mode.
@param FtwLiteDevice Point to private data of FTW driver.
@param Size The size of buffer to allocate.
@retval NULL Allocate buffer failed.
@return EFI_INVALID_PARAMETER Start address of allocated buffer.
**/
VOID *
FtwAllocateZeroBuffer (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN UINTN Size
);
/**
This function uses to free memory which allocated by FtwAllocateZeroBuffer ()
@param FtwLiteDevice Point to private data of FTW driver.
@param Buffer [in]:Double pointer saved the pointer of buffer address which want to free
[out]:Double pointer Saved NULL pointer to indicate allocated memory is freed.
@retval EFI_SUCCESS Memory return to system
@return EFI_INVALID_PARAMETER Buffer was invalid.
**/
EFI_STATUS
FtwFreePool (
IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,
IN OUT VOID **Buffer
);
/**
Check this input handle is whether a NV store FVB handle.
@param[in] Handle Input EFI_HANDLE instance
@retval TRUE This is NV storage FVB handle.
@retval FALSE This isn't NV storage FVB handle.
**/
BOOLEAN
IsNvStorageHandle (
EFI_HANDLE Handle
);
extern EFI_SMM_SYSTEM_TABLE2 *mSmst;
#ifndef MDEPKG_NDEBUG
extern UINTN mFtwLiteInfo;
extern UINTN mFtwLiteError;
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink