\r
Internal generic functions to operate flash block.\r
\r
-Copyright (c) 2006 - 2008, Intel Corporation \r
-All rights reserved. This program and the accompanying materials \r
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
http://opensource.org/licenses/bsd-license.php \r
}\r
\r
/**\r
- To erase the block with the spare block size.\r
+ To erase the block with specified blocks.\r
\r
\r
@param FtwDevice The private data of FTW driver\r
@param FvBlock FVB Protocol interface\r
@param Lba Lba of the firmware block\r
+ @param NumberOfBlocks The number of consecutive blocks starting with Lba\r
\r
@retval EFI_SUCCESS Block LBA is Erased successfully\r
@retval Others Error occurs\r
FtwEraseBlock (\r
IN EFI_FTW_DEVICE *FtwDevice,\r
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
- EFI_LBA Lba\r
+ EFI_LBA Lba,\r
+ UINTN NumberOfBlocks\r
)\r
{\r
return FvBlock->EraseBlocks (\r
FvBlock,\r
Lba,\r
- FtwDevice->NumberOfSpareBlock,\r
+ NumberOfBlocks,\r
EFI_LBA_LIST_TERMINATOR\r
);\r
}\r
);\r
}\r
\r
-/**\r
- Retrive the proper FVB protocol interface by HANDLE.\r
-\r
-\r
- @param FvBlockHandle The handle of FVB protocol that provides services for\r
- reading, writing, and erasing the target block.\r
- @param FvBlock The interface of FVB protocol\r
-\r
- @retval EFI_SUCCESS The function completed successfully\r
- @retval EFI_ABORTED The function could not complete successfully\r
-\r
-**/\r
-EFI_STATUS\r
-FtwGetFvbByHandle (\r
- IN EFI_HANDLE FvBlockHandle,\r
- OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock\r
- )\r
-{\r
- //\r
- // To get the FVB protocol interface on the handle\r
- //\r
- return gBS->HandleProtocol (\r
- FvBlockHandle,\r
- &gEfiFirmwareVolumeBlockProtocolGuid,\r
- (VOID **) FvBlock\r
- );\r
-}\r
-\r
/**\r
\r
Is it in working block?\r
\r
/**\r
\r
- Get firmware block by address.\r
+ Get firmware volume block by address.\r
\r
\r
@param Address Address specified the block\r
UINTN Index;\r
EFI_PHYSICAL_ADDRESS FvbBaseAddress;\r
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
- EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
EFI_HANDLE FvbHandle;\r
+ UINTN BlockSize;\r
+ UINTN NumberOfBlocks;\r
\r
*FvBlock = NULL;\r
FvbHandle = NULL;\r
+ HandleBuffer = NULL;\r
//\r
// Locate all handles of Fvb protocol\r
//\r
- Status = gBS->LocateHandleBuffer (\r
- ByProtocol,\r
- &gEfiFirmwareVolumeBlockProtocolGuid,\r
- NULL,\r
- &HandleCount,\r
- &HandleBuffer\r
- );\r
+ Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);\r
if (EFI_ERROR (Status)) {\r
return NULL;\r
}\r
// Get the FVB to access variable store\r
//\r
for (Index = 0; Index < HandleCount; Index += 1) {\r
- Status = gBS->HandleProtocol (\r
- HandleBuffer[Index],\r
- &gEfiFirmwareVolumeBlockProtocolGuid,\r
- (VOID **) &Fvb\r
- );\r
+ Status = FtwGetFvbByHandle (HandleBuffer[Index], &Fvb);\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
continue;\r
}\r
\r
- FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);\r
- if ((Address >= FvbBaseAddress) && (Address <= (FvbBaseAddress + (FwVolHeader->FvLength - 1)))) {\r
+ //\r
+ // Now, one FVB has one type of BlockSize\r
+ //\r
+ Status = Fvb->GetBlockSize (Fvb, 0, &BlockSize, &NumberOfBlocks);\r
+ if (EFI_ERROR (Status)) {\r
+ continue;\r
+ }\r
+\r
+ if ((Address >= FvbBaseAddress) && (Address < (FvbBaseAddress + BlockSize * NumberOfBlocks))) {\r
*FvBlock = Fvb;\r
FvbHandle = HandleBuffer[Index];\r
break;\r
\r
@param FtwDevice The private data of FTW driver\r
@param FvBlock Fvb protocol instance\r
- @param Lba The block specified\r
\r
@return A BOOLEAN value indicating in boot block or not.\r
\r
BOOLEAN\r
IsBootBlock (\r
EFI_FTW_DEVICE *FtwDevice,\r
- EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
- EFI_LBA Lba\r
+ EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock\r
)\r
{\r
EFI_STATUS Status;\r
return FALSE;\r
}\r
\r
- Status = gBS->LocateProtocol (&gEfiSwapAddressRangeProtocolGuid, NULL, (VOID **) &SarProtocol);\r
+ Status = FtwGetSarProtocol ((VOID **) &SarProtocol);\r
if (EFI_ERROR (Status)) {\r
return FALSE;\r
}\r
\r
/**\r
Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE.\r
- Spare block is accessed by FTW working FVB protocol interface. LBA is 1.\r
- Target block is accessed by FvbBlock protocol interface. LBA is Lba.\r
+ Spare block is accessed by FTW working FVB protocol interface.\r
+ Target block is accessed by FvBlock protocol interface.\r
\r
FTW will do extra work on boot block update.\r
FTW should depend on a protocol of EFI_ADDRESS_RANGE_SWAP_PROTOCOL,\r
1. GetRangeLocation(), if the Range is inside the boot block, FTW know\r
that boot block will be update. It shall add a FLAG in the working block.\r
2. When spare block is ready,\r
- 3. SetSwapState(EFI_SWAPPED)\r
+ 3. SetSwapState(SWAPPED)\r
4. erasing boot block,\r
5. programming boot block until the boot block is ok.\r
6. SetSwapState(UNSWAPPED)\r
//\r
// Locate swap address range protocol\r
//\r
- Status = gBS->LocateProtocol (&gEfiSwapAddressRangeProtocolGuid, NULL, (VOID **) &SarProtocol);\r
+ Status = FtwGetSarProtocol ((VOID **) &SarProtocol);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
BootLba = 0;\r
Ptr = Buffer;\r
for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ Count = FtwDevice->SpareBlockSize;\r
Status = BootFvb->Read (\r
BootFvb,\r
BootLba + Index,\r
//\r
Ptr = Buffer;\r
for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ Count = FtwDevice->SpareBlockSize;\r
Status = FtwDevice->FtwBackupFvb->Read (\r
FtwDevice->FtwBackupFvb,\r
FtwDevice->FtwSpareLba + Index,\r
return EFI_ABORTED;\r
}\r
//\r
- // Write memory buffer currenet spare block. Still top block.\r
+ // Write memory buffer to current spare block. Still top block.\r
//\r
Ptr = Buffer;\r
for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ Count = FtwDevice->SpareBlockSize;\r
Status = FtwDevice->FtwBackupFvb->Write (\r
FtwDevice->FtwBackupFvb,\r
FtwDevice->FtwSpareLba + Index,\r
}\r
\r
/**\r
- Copy the content of spare block to a target block. Size is FTW_BLOCK_SIZE.\r
- Spare block is accessed by FTW backup FVB protocol interface. LBA is 1.\r
- Target block is accessed by FvbBlock protocol interface. LBA is Lba.\r
+ Copy the content of spare block to a target block.\r
+ Spare block is accessed by FTW backup FVB protocol interface.\r
+ Target block is accessed by FvBlock protocol interface.\r
\r
\r
@param FtwDevice The private data of FTW driver\r
@param FvBlock FVB Protocol interface to access target block\r
@param Lba Lba of the target block\r
+ @param BlockSize The size of the block\r
+ @param NumberOfBlocks The number of consecutive blocks starting with Lba\r
\r
@retval EFI_SUCCESS Spare block content is copied to target block\r
@retval EFI_INVALID_PARAMETER Input parameter error\r
FlushSpareBlockToTargetBlock (\r
EFI_FTW_DEVICE *FtwDevice,\r
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
- EFI_LBA Lba\r
+ EFI_LBA Lba,\r
+ UINTN BlockSize,\r
+ UINTN NumberOfBlocks\r
)\r
{\r
EFI_STATUS Status;\r
//\r
Ptr = Buffer;\r
for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ Count = FtwDevice->SpareBlockSize;\r
Status = FtwDevice->FtwBackupFvb->Read (\r
FtwDevice->FtwBackupFvb,\r
FtwDevice->FtwSpareLba + Index,\r
//\r
// Erase the target block\r
//\r
- Status = FtwEraseBlock (FtwDevice, FvBlock, Lba);\r
+ Status = FtwEraseBlock (FtwDevice, FvBlock, Lba, NumberOfBlocks);\r
if (EFI_ERROR (Status)) {\r
FreePool (Buffer);\r
return EFI_ABORTED;\r
}\r
//\r
- // Write memory buffer to block, using the FvbBlock protocol interface\r
+ // Write memory buffer to block, using the FvBlock protocol interface\r
//\r
Ptr = Buffer;\r
- for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ for (Index = 0; Index < NumberOfBlocks; Index += 1) {\r
+ Count = BlockSize;\r
Status = FvBlock->Write (FvBlock, Lba + Index, 0, &Count, Ptr);\r
if (EFI_ERROR (Status)) {\r
DEBUG ((EFI_D_ERROR, "Ftw: FVB Write block - %r\n", Status));\r
UINTN Count;\r
UINT8 *Ptr;\r
UINTN Index;\r
- EFI_LBA WorkSpaceLbaOffset;\r
\r
//\r
// Allocate a memory buffer\r
if (Buffer == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+\r
//\r
// To guarantee that the WorkingBlockValid is set on spare block\r
//\r
//\r
FtwUpdateFvState (\r
FtwDevice->FtwBackupFvb,\r
- FtwDevice->FtwWorkSpaceLba,\r
- FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
+ FtwDevice->SpareBlockSize,\r
+ FtwDevice->FtwSpareLba + FtwDevice->FtwWorkSpaceLbaInSpare,\r
+ FtwDevice->FtwWorkSpaceBaseInSpare + sizeof (EFI_GUID) + sizeof (UINT32),\r
WORKING_BLOCK_VALID\r
);\r
//\r
//\r
Ptr = Buffer;\r
for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ Count = FtwDevice->SpareBlockSize;\r
Status = FtwDevice->FtwBackupFvb->Read (\r
FtwDevice->FtwBackupFvb,\r
FtwDevice->FtwSpareLba + Index,\r
//\r
// Clear the CRC and STATE, copy data from spare to working block.\r
//\r
- WorkSpaceLbaOffset = FtwDevice->FtwWorkSpaceLba - FtwDevice->FtwWorkBlockLba;\r
- WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (Buffer + (UINTN) WorkSpaceLbaOffset * FtwDevice->BlockSize + FtwDevice->FtwWorkSpaceBase);\r
+ WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (Buffer + (UINTN) FtwDevice->FtwWorkSpaceLbaInSpare * FtwDevice->SpareBlockSize + FtwDevice->FtwWorkSpaceBaseInSpare);\r
InitWorkSpaceHeader (WorkingBlockHeader);\r
WorkingBlockHeader->WorkingBlockValid = FTW_ERASE_POLARITY;\r
WorkingBlockHeader->WorkingBlockInvalid = FTW_ERASE_POLARITY;\r
//\r
Status = FtwUpdateFvState (\r
FtwDevice->FtwFvBlock,\r
+ FtwDevice->WorkBlockSize,\r
FtwDevice->FtwWorkSpaceLba,\r
FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
WORKING_BLOCK_INVALID\r
//\r
// Erase the working block\r
//\r
- Status = FtwEraseBlock (FtwDevice, FtwDevice->FtwFvBlock, FtwDevice->FtwWorkBlockLba);\r
+ Status = FtwEraseBlock (FtwDevice, FtwDevice->FtwFvBlock, FtwDevice->FtwWorkBlockLba, FtwDevice->NumberOfWorkBlock);\r
if (EFI_ERROR (Status)) {\r
FreePool (Buffer);\r
return EFI_ABORTED;\r
}\r
//\r
- // Write memory buffer to working block, using the FvbBlock protocol interface\r
+ // Write memory buffer to working block, using the FvBlock protocol interface\r
//\r
Ptr = Buffer;\r
- for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
- Count = FtwDevice->BlockSize;\r
+ for (Index = 0; Index < FtwDevice->NumberOfWorkBlock; Index += 1) {\r
+ Count = FtwDevice->WorkBlockSize;\r
Status = FtwDevice->FtwFvBlock->Write (\r
FtwDevice->FtwFvBlock,\r
FtwDevice->FtwWorkBlockLba + Index,\r
//\r
Status = FtwUpdateFvState (\r
FtwDevice->FtwFvBlock,\r
+ FtwDevice->WorkBlockSize,\r
FtwDevice->FtwWorkSpaceLba,\r
FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
WORKING_BLOCK_VALID\r
return EFI_ABORTED;\r
}\r
\r
+ FtwDevice->FtwWorkSpaceHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
FtwDevice->FtwWorkSpaceHeader->WorkingBlockValid = FTW_VALID_STATE;\r
\r
return EFI_SUCCESS;\r
\r
\r
@param FvBlock FVB Protocol interface to access SrcBlock and DestBlock\r
+ @param BlockSize The size of the block\r
@param Lba Lba of a block\r
@param Offset Offset on the Lba\r
@param NewBit New value that will override the old value if it can be change\r
EFI_STATUS\r
FtwUpdateFvState (\r
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
+ IN UINTN BlockSize,\r
IN EFI_LBA Lba,\r
IN UINTN Offset,\r
IN UINT8 NewBit\r
UINT8 State;\r
UINTN Length;\r
\r
+ //\r
+ // Calculate the real Offset and Lba to write.\r
+ //\r
+ while (Offset >= BlockSize) {\r
+ Offset -= BlockSize;\r
+ Lba++;\r
+ }\r
+\r
//\r
// Read state from device, assume State is only one byte.\r
//\r
Offset = sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER);\r
\r
while (FtwHeader->Complete == FTW_VALID_STATE) {\r
- Offset += WRITE_TOTAL_SIZE (FtwHeader->NumberOfWrites, FtwHeader->PrivateDataSize);\r
+ Offset += FTW_WRITE_TOTAL_SIZE (FtwHeader->NumberOfWrites, FtwHeader->PrivateDataSize);\r
//\r
// If Offset exceed the FTW work space boudary, return error.\r
//\r
- if (Offset > FtwWorkSpaceSize) {\r
+ if (Offset >= FtwWorkSpaceSize) {\r
*FtwWriteHeader = FtwHeader;\r
return EFI_ABORTED;\r
}\r
FtwRecord++;\r
\r
if (FtwWriteHeader->PrivateDataSize != 0) {\r
- FtwRecord = (EFI_FAULT_TOLERANT_WRITE_RECORD *) ((UINTN) FtwRecord + FtwWriteHeader->PrivateDataSize);\r
+ FtwRecord = (EFI_FAULT_TOLERANT_WRITE_RECORD *) ((UINTN) FtwRecord + (UINTN) FtwWriteHeader->PrivateDataSize);\r
}\r
}\r
//\r
// also return the last record.\r
//\r
if (Index == FtwWriteHeader->NumberOfWrites) {\r
- *FtwWriteRecord = (EFI_FAULT_TOLERANT_WRITE_RECORD *) ((UINTN) FtwRecord - RECORD_SIZE (FtwWriteHeader->PrivateDataSize));\r
+ *FtwWriteRecord = (EFI_FAULT_TOLERANT_WRITE_RECORD *) ((UINTN) FtwRecord - FTW_RECORD_SIZE (FtwWriteHeader->PrivateDataSize));\r
return EFI_SUCCESS;\r
}\r
\r
Head = (UINT8 *) FtwHeader;\r
Ptr = (UINT8 *) FtwRecord;\r
\r
- Head += WRITE_TOTAL_SIZE (FtwHeader->NumberOfWrites - 1, FtwHeader->PrivateDataSize);\r
+ Head += FTW_WRITE_TOTAL_SIZE (FtwHeader->NumberOfWrites - 1, FtwHeader->PrivateDataSize);\r
return (BOOLEAN) (Head == Ptr);\r
}\r
\r
}\r
\r
Ptr = (UINT8 *) (*FtwRecord);\r
- Ptr -= RECORD_SIZE (FtwHeader->PrivateDataSize);\r
+ Ptr -= FTW_RECORD_SIZE (FtwHeader->PrivateDataSize);\r
*FtwRecord = (EFI_FAULT_TOLERANT_WRITE_RECORD *) Ptr;\r
return EFI_SUCCESS;\r
}\r
+\r
+/**\r
+ Allocate private data for FTW driver and initialize it.\r
+\r
+ @param[out] FtwData Pointer to the FTW device structure\r
+\r
+ @retval EFI_SUCCESS Initialize the FTW device successfully.\r
+ @retval EFI_OUT_OF_RESOURCES Allocate memory error\r
+ @retval EFI_INVALID_PARAMETER Workspace or Spare block does not exist\r
+\r
+**/\r
+EFI_STATUS\r
+InitFtwDevice (\r
+ OUT EFI_FTW_DEVICE **FtwData \r
+ )\r
+{\r
+ EFI_FTW_DEVICE *FtwDevice;\r
+ \r
+ //\r
+ // Allocate private data of this driver,\r
+ // Including the FtwWorkSpace[FTW_WORK_SPACE_SIZE].\r
+ //\r
+ FtwDevice = AllocateZeroPool (sizeof (EFI_FTW_DEVICE) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize));\r
+ if (FtwDevice == NULL) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ //\r
+ // Initialize other parameters, and set WorkSpace as FTW_ERASED_BYTE.\r
+ //\r
+ FtwDevice->WorkSpaceLength = (UINTN) PcdGet32 (PcdFlashNvStorageFtwWorkingSize);\r
+ FtwDevice->SpareAreaLength = (UINTN) PcdGet32 (PcdFlashNvStorageFtwSpareSize);\r
+ if ((FtwDevice->WorkSpaceLength == 0) || (FtwDevice->SpareAreaLength == 0)) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Workspace or Spare block does not exist!\n"));\r
+ FreePool (FtwDevice);\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
+ FtwDevice->Signature = FTW_DEVICE_SIGNATURE;\r
+ FtwDevice->FtwFvBlock = NULL;\r
+ FtwDevice->FtwBackupFvb = NULL;\r
+ FtwDevice->FtwWorkSpaceLba = (EFI_LBA) (-1);\r
+ FtwDevice->FtwSpareLba = (EFI_LBA) (-1);\r
+\r
+ FtwDevice->WorkSpaceAddress = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageFtwWorkingBase64);\r
+ if (FtwDevice->WorkSpaceAddress == 0) {\r
+ FtwDevice->WorkSpaceAddress = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageFtwWorkingBase);\r
+ }\r
+ \r
+ FtwDevice->SpareAreaAddress = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageFtwSpareBase64);\r
+ if (FtwDevice->SpareAreaAddress == 0) {\r
+ FtwDevice->SpareAreaAddress = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageFtwSpareBase);\r
+ } \r
+\r
+ *FtwData = FtwDevice;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Find the proper Firmware Volume Block protocol for FTW operation.\r
+\r
+ @param[in, out] FtwDevice Pointer to the FTW device structure\r
+\r
+ @retval EFI_SUCCESS Find the FVB protocol successfully.\r
+ @retval EFI_NOT_FOUND No proper FVB protocol was found.\r
+ @retval EFI_ABORTED Some data can not be got or be invalid.\r
+ \r
+**/\r
+EFI_STATUS\r
+FindFvbForFtw (\r
+ IN OUT EFI_FTW_DEVICE *FtwDevice\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_HANDLE *HandleBuffer;\r
+ UINTN HandleCount;\r
+ UINTN Index;\r
+ EFI_PHYSICAL_ADDRESS FvbBaseAddress;\r
+ EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
+ EFI_FVB_ATTRIBUTES_2 Attributes;\r
+ UINT32 LbaIndex;\r
+ UINTN BlockSize;\r
+ UINTN NumberOfBlocks;\r
+\r
+ HandleBuffer = NULL;\r
+\r
+ //\r
+ // Get all FVB handle.\r
+ //\r
+ Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);\r
+ if (EFI_ERROR (Status)) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ //\r
+ // Get the FVB to access variable store\r
+ //\r
+ Fvb = NULL;\r
+ for (Index = 0; Index < HandleCount; Index += 1) {\r
+ Status = FtwGetFvbByHandle (HandleBuffer[Index], &Fvb);\r
+ if (EFI_ERROR (Status)) {\r
+ Status = EFI_NOT_FOUND;\r
+ break;\r
+ }\r
+\r
+ //\r
+ // Ensure this FVB protocol support Write operation.\r
+ //\r
+ Status = Fvb->GetAttributes (Fvb, &Attributes);\r
+ if (EFI_ERROR (Status) || ((Attributes & EFI_FVB2_WRITE_STATUS) == 0)) {\r
+ continue; \r
+ }\r
+ //\r
+ // Compare the address and select the right one\r
+ //\r
+ Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);\r
+ if (EFI_ERROR (Status)) {\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Now, one FVB has one type of BlockSize.\r
+ //\r
+ Status = Fvb->GetBlockSize (Fvb, 0, &BlockSize, &NumberOfBlocks);\r
+ if (EFI_ERROR (Status)) {\r
+ continue;\r
+ }\r
+\r
+ if ((FtwDevice->FtwFvBlock == NULL) && (FtwDevice->WorkSpaceAddress >= FvbBaseAddress) &&\r
+ ((FtwDevice->WorkSpaceAddress + FtwDevice->WorkSpaceLength) <= (FvbBaseAddress + BlockSize * NumberOfBlocks))) {\r
+ FtwDevice->FtwFvBlock = Fvb;\r
+ //\r
+ // To get the LBA of work space\r
+ //\r
+ for (LbaIndex = 1; LbaIndex <= NumberOfBlocks; LbaIndex += 1) {\r
+ if ((FtwDevice->WorkSpaceAddress >= (FvbBaseAddress + BlockSize * (LbaIndex - 1)))\r
+ && (FtwDevice->WorkSpaceAddress < (FvbBaseAddress + BlockSize * LbaIndex))) {\r
+ FtwDevice->FtwWorkSpaceLba = LbaIndex - 1;\r
+ //\r
+ // Get the Work space size and Base(Offset)\r
+ //\r
+ FtwDevice->FtwWorkSpaceSize = FtwDevice->WorkSpaceLength;\r
+ FtwDevice->WorkBlockSize = BlockSize;\r
+ FtwDevice->FtwWorkSpaceBase = (UINTN) (FtwDevice->WorkSpaceAddress - (FvbBaseAddress + FtwDevice->WorkBlockSize * (LbaIndex - 1)));\r
+ FtwDevice->NumberOfWorkSpaceBlock = FTW_BLOCKS (FtwDevice->FtwWorkSpaceBase + FtwDevice->FtwWorkSpaceSize, FtwDevice->WorkBlockSize);\r
+ if (FtwDevice->FtwWorkSpaceSize >= FtwDevice->WorkBlockSize) {\r
+ //\r
+ // Check the alignment of work space address and length, they should be block size aligned when work space size is larger than one block size.\r
+ //\r
+ if (((FtwDevice->WorkSpaceAddress & (FtwDevice->WorkBlockSize - 1)) != 0) ||\r
+ ((FtwDevice->WorkSpaceLength & (FtwDevice->WorkBlockSize - 1)) != 0)) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Work space address or length is not block size aligned when work space size is larger than one block size\n"));\r
+ FreePool (HandleBuffer);\r
+ ASSERT (FALSE);\r
+ return EFI_ABORTED;\r
+ }\r
+ } else if ((FtwDevice->FtwWorkSpaceBase + FtwDevice->FtwWorkSpaceSize) > FtwDevice->WorkBlockSize) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: The work space range should not span blocks when work space size is less than one block size\n"));\r
+ FreePool (HandleBuffer);\r
+ ASSERT (FALSE);\r
+ return EFI_ABORTED;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ if ((FtwDevice->FtwBackupFvb == NULL) && (FtwDevice->SpareAreaAddress >= FvbBaseAddress) &&\r
+ ((FtwDevice->SpareAreaAddress + FtwDevice->SpareAreaLength) <= (FvbBaseAddress + BlockSize * NumberOfBlocks))) {\r
+ FtwDevice->FtwBackupFvb = Fvb;\r
+ //\r
+ // To get the LBA of spare\r
+ //\r
+ for (LbaIndex = 1; LbaIndex <= NumberOfBlocks; LbaIndex += 1) {\r
+ if ((FtwDevice->SpareAreaAddress >= (FvbBaseAddress + BlockSize * (LbaIndex - 1)))\r
+ && (FtwDevice->SpareAreaAddress < (FvbBaseAddress + BlockSize * LbaIndex))) {\r
+ //\r
+ // Get the NumberOfSpareBlock and BlockSize\r
+ //\r
+ FtwDevice->FtwSpareLba = LbaIndex - 1;\r
+ FtwDevice->SpareBlockSize = BlockSize;\r
+ FtwDevice->NumberOfSpareBlock = FtwDevice->SpareAreaLength / FtwDevice->SpareBlockSize;\r
+ //\r
+ // Check the range of spare area to make sure that it's in FV range\r
+ //\r
+ if ((FtwDevice->FtwSpareLba + FtwDevice->NumberOfSpareBlock) > NumberOfBlocks) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Spare area is out of FV range\n"));\r
+ FreePool (HandleBuffer);\r
+ ASSERT (FALSE);\r
+ return EFI_ABORTED;\r
+ }\r
+ //\r
+ // Check the alignment of spare area address and length, they should be block size aligned\r
+ //\r
+ if (((FtwDevice->SpareAreaAddress & (FtwDevice->SpareBlockSize - 1)) != 0) ||\r
+ ((FtwDevice->SpareAreaLength & (FtwDevice->SpareBlockSize - 1)) != 0)) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Spare area address or length is not block size aligned\n"));\r
+ FreePool (HandleBuffer);\r
+ //\r
+ // Report Status Code EFI_SW_EC_ABORTED.\r
+ //\r
+ REPORT_STATUS_CODE ((EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED), (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ABORTED));\r
+ ASSERT (FALSE);\r
+ CpuDeadLoop ();\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ FreePool (HandleBuffer);\r
+\r
+ if ((FtwDevice->FtwBackupFvb == NULL) || (FtwDevice->FtwFvBlock == NULL) ||\r
+ (FtwDevice->FtwWorkSpaceLba == (EFI_LBA) (-1)) || (FtwDevice->FtwSpareLba == (EFI_LBA) (-1))) {\r
+ return EFI_ABORTED;\r
+ }\r
+ DEBUG ((EFI_D_INFO, "Ftw: FtwWorkSpaceLba - 0x%lx, WorkBlockSize - 0x%x, FtwWorkSpaceBase - 0x%x\n", FtwDevice->FtwWorkSpaceLba, FtwDevice->WorkBlockSize, FtwDevice->FtwWorkSpaceBase));\r
+ DEBUG ((EFI_D_INFO, "Ftw: FtwSpareLba - 0x%lx, SpareBlockSize - 0x%x\n", FtwDevice->FtwSpareLba, FtwDevice->SpareBlockSize));\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Initialization for Fault Tolerant Write protocol.\r
+\r
+ @param[in, out] FtwDevice Pointer to the FTW device structure\r
+\r
+ @retval EFI_SUCCESS Initialize the FTW protocol successfully.\r
+ @retval EFI_NOT_FOUND No proper FVB protocol was found.\r
+ \r
+**/\r
+EFI_STATUS\r
+InitFtwProtocol (\r
+ IN OUT EFI_FTW_DEVICE *FtwDevice\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
+ EFI_FAULT_TOLERANT_WRITE_HEADER *FtwHeader;\r
+ UINTN Offset;\r
+ EFI_HANDLE FvbHandle;\r
+ EFI_LBA WorkSpaceLbaOffset;\r
+\r
+ //\r
+ // Find the right SMM Fvb protocol instance for FTW.\r
+ //\r
+ Status = FindFvbForFtw (FtwDevice);\r
+ if (EFI_ERROR (Status)) {\r
+ return EFI_NOT_FOUND;\r
+ } \r
+\r
+ //\r
+ // Calculate the start LBA of working block.\r
+ //\r
+ if (FtwDevice->FtwWorkSpaceSize >= FtwDevice->WorkBlockSize) {\r
+ //\r
+ // Working block is a standalone area which only contains working space.\r
+ //\r
+ FtwDevice->NumberOfWorkBlock = FtwDevice->NumberOfWorkSpaceBlock;\r
+ } else {\r
+ //\r
+ // Working block is an area which\r
+ // contains working space in its last block and has the same size as spare\r
+ // block, unless there are not enough blocks before the block that contains\r
+ // working space.\r
+ //\r
+ FtwDevice->NumberOfWorkBlock = (UINTN) (FtwDevice->FtwWorkSpaceLba + FtwDevice->NumberOfWorkSpaceBlock);\r
+ while (FtwDevice->NumberOfWorkBlock * FtwDevice->WorkBlockSize > FtwDevice->SpareAreaLength) {\r
+ FtwDevice->NumberOfWorkBlock--;\r
+ }\r
+ }\r
+ FtwDevice->FtwWorkBlockLba = FtwDevice->FtwWorkSpaceLba + FtwDevice->NumberOfWorkSpaceBlock - FtwDevice->NumberOfWorkBlock;\r
+ DEBUG ((EFI_D_INFO, "Ftw: NumberOfWorkBlock - 0x%x, FtwWorkBlockLba - 0x%lx\n", FtwDevice->NumberOfWorkBlock, FtwDevice->FtwWorkBlockLba));\r
+\r
+ //\r
+ // Calcualte the LBA and base of work space in spare block.\r
+ // Note: Do not assume Spare Block and Work Block have same block size.\r
+ //\r
+ WorkSpaceLbaOffset = FtwDevice->FtwWorkSpaceLba - FtwDevice->FtwWorkBlockLba;\r
+ FtwDevice->FtwWorkSpaceLbaInSpare = (EFI_LBA) (((UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize + FtwDevice->FtwWorkSpaceBase) / FtwDevice->SpareBlockSize);\r
+ FtwDevice->FtwWorkSpaceBaseInSpare = ((UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize + FtwDevice->FtwWorkSpaceBase) % FtwDevice->SpareBlockSize;\r
+ DEBUG ((EFI_D_INFO, "Ftw: WorkSpaceLbaInSpare - 0x%lx, WorkSpaceBaseInSpare - 0x%x\n", FtwDevice->FtwWorkSpaceLbaInSpare, FtwDevice->FtwWorkSpaceBaseInSpare));\r
+\r
+ //\r
+ // Initialize other parameters, and set WorkSpace as FTW_ERASED_BYTE.\r
+ //\r
+ FtwDevice->FtwWorkSpace = (UINT8 *) (FtwDevice + 1);\r
+ FtwDevice->FtwWorkSpaceHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) FtwDevice->FtwWorkSpace;\r
+\r
+ FtwDevice->FtwLastWriteHeader = NULL;\r
+ FtwDevice->FtwLastWriteRecord = NULL;\r
+\r
+ InitializeLocalWorkSpaceHeader ();\r
+\r
+ //\r
+ // Refresh the working space data from working block\r
+ //\r
+ Status = WorkSpaceRefresh (FtwDevice);\r
+ ASSERT_EFI_ERROR (Status);\r
+ //\r
+ // If the working block workspace is not valid, try the spare block\r
+ //\r
+ if (!IsValidWorkSpace (FtwDevice->FtwWorkSpaceHeader)) {\r
+ //\r
+ // Read from spare block\r
+ //\r
+ Status = ReadWorkSpaceData (\r
+ FtwDevice->FtwBackupFvb,\r
+ FtwDevice->SpareBlockSize,\r
+ FtwDevice->FtwSpareLba + FtwDevice->FtwWorkSpaceLbaInSpare,\r
+ FtwDevice->FtwWorkSpaceBaseInSpare,\r
+ FtwDevice->FtwWorkSpaceSize,\r
+ FtwDevice->FtwWorkSpace\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ //\r
+ // If spare block is valid, then replace working block content.\r
+ //\r
+ if (IsValidWorkSpace (FtwDevice->FtwWorkSpaceHeader)) {\r
+ Status = FlushSpareBlockToWorkingBlock (FtwDevice);\r
+ DEBUG ((EFI_D_INFO, "Ftw: Restart working block update in %a() - %r\n",\r
+ __FUNCTION__, Status));\r
+ FtwAbort (&FtwDevice->FtwInstance);\r
+ //\r
+ // Refresh work space.\r
+ //\r
+ Status = WorkSpaceRefresh (FtwDevice);\r
+ ASSERT_EFI_ERROR (Status);\r
+ } else {\r
+ DEBUG ((EFI_D_INFO,\r
+ "Ftw: Both working and spare blocks are invalid, init workspace\n"));\r
+ //\r
+ // If both are invalid, then initialize work space.\r
+ //\r
+ SetMem (\r
+ FtwDevice->FtwWorkSpace,\r
+ FtwDevice->FtwWorkSpaceSize,\r
+ FTW_ERASED_BYTE\r
+ );\r
+ InitWorkSpaceHeader (FtwDevice->FtwWorkSpaceHeader);\r
+ //\r
+ // Initialize the work space\r
+ //\r
+ Status = FtwReclaimWorkSpace (FtwDevice, FALSE);\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+ }\r
+ //\r
+ // If the FtwDevice->FtwLastWriteRecord is 1st record of write header &&\r
+ // (! SpareComplete) THEN call Abort().\r
+ //\r
+ if ((FtwDevice->FtwLastWriteHeader->HeaderAllocated == FTW_VALID_STATE) &&\r
+ (FtwDevice->FtwLastWriteRecord->SpareComplete != FTW_VALID_STATE) &&\r
+ IsFirstRecordOfWrites (FtwDevice->FtwLastWriteHeader, FtwDevice->FtwLastWriteRecord)\r
+ ) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Init.. find first record not SpareCompleted, abort()\n"));\r
+ FtwAbort (&FtwDevice->FtwInstance);\r
+ }\r
+ //\r
+ // If Header is incompleted and the last record has completed, then\r
+ // call Abort() to set the Header->Complete FLAG.\r
+ //\r
+ if ((FtwDevice->FtwLastWriteHeader->Complete != FTW_VALID_STATE) &&\r
+ (FtwDevice->FtwLastWriteRecord->DestinationComplete == FTW_VALID_STATE) &&\r
+ IsLastRecordOfWrites (FtwDevice->FtwLastWriteHeader, FtwDevice->FtwLastWriteRecord)\r
+ ) {\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Init.. find last record completed but header not, abort()\n"));\r
+ FtwAbort (&FtwDevice->FtwInstance);\r
+ }\r
+ //\r
+ // To check the workspace buffer following last Write header/records is EMPTY or not.\r
+ // If it's not EMPTY, FTW also need to call reclaim().\r
+ //\r
+ FtwHeader = FtwDevice->FtwLastWriteHeader;\r
+ Offset = (UINT8 *) FtwHeader - FtwDevice->FtwWorkSpace;\r
+ if (FtwDevice->FtwWorkSpace[Offset] != FTW_ERASED_BYTE) {\r
+ Offset += FTW_WRITE_TOTAL_SIZE (FtwHeader->NumberOfWrites, FtwHeader->PrivateDataSize);\r
+ }\r
+ \r
+ if (!IsErasedFlashBuffer (FtwDevice->FtwWorkSpace + Offset, FtwDevice->FtwWorkSpaceSize - Offset)) {\r
+ Status = FtwReclaimWorkSpace (FtwDevice, TRUE);\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+\r
+ //\r
+ // Restart if it's boot block\r
+ //\r
+ if ((FtwDevice->FtwLastWriteHeader->Complete != FTW_VALID_STATE) &&\r
+ (FtwDevice->FtwLastWriteRecord->SpareComplete == FTW_VALID_STATE)\r
+ ) {\r
+ if (FtwDevice->FtwLastWriteRecord->BootBlockUpdate == FTW_VALID_STATE) {\r
+ Status = FlushSpareBlockToBootBlock (FtwDevice);\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Restart boot block update - %r\n", Status));\r
+ ASSERT_EFI_ERROR (Status);\r
+ FtwAbort (&FtwDevice->FtwInstance);\r
+ } else {\r
+ //\r
+ // if (SpareCompleted) THEN Restart to fault tolerant write.\r
+ //\r
+ FvbHandle = NULL;\r
+ FvbHandle = GetFvbByAddress ((EFI_PHYSICAL_ADDRESS) (UINTN) ((INT64) FtwDevice->SpareAreaAddress + FtwDevice->FtwLastWriteRecord->RelativeOffset), &Fvb);\r
+ if (FvbHandle != NULL) {\r
+ Status = FtwRestart (&FtwDevice->FtwInstance, FvbHandle);\r
+ DEBUG ((EFI_D_ERROR, "Ftw: Restart last write - %r\n", Status));\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+ FtwAbort (&FtwDevice->FtwInstance);\r
+ }\r
+ }\r
+ //\r
+ // Hook the protocol API\r
+ //\r
+ FtwDevice->FtwInstance.GetMaxBlockSize = FtwGetMaxBlockSize;\r
+ FtwDevice->FtwInstance.Allocate = FtwAllocate;\r
+ FtwDevice->FtwInstance.Write = FtwWrite;\r
+ FtwDevice->FtwInstance.Restart = FtwRestart;\r
+ FtwDevice->FtwInstance.Abort = FtwAbort;\r
+ FtwDevice->FtwInstance.GetLastWrite = FtwGetLastWrite;\r
+ \r
+ return EFI_SUCCESS;\r
+}\r
+\r
projects / mirror_edk2.git / blobdiff