[mirror_edk2.git] / MdeModulePkg / Universal / FirmwareVolume / FaultTolerantWriteDxe / FtwWorkSpace.c

/** @file\r
\r
   Internal functions to operate Working Block Space.\r
\r
Copyright (c) 2006 - 2008, Intel Corporation                                                         \r
All rights reserved. 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
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
\r
**/\r
\r
\r
#include <FtwLite.h>\r
\r
/**\r
  Check to see if it is a valid work space.\r
\r
\r
  @param WorkingHeader   Pointer of working block header\r
\r
  @retval  EFI_SUCCESS    The function completed successfully\r
  @retval  EFI_ABORTED    The function could not complete successfully.\r
\r
**/\r
BOOLEAN\r
IsValidWorkSpace (\r
  IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
  )\r
{\r
  EFI_STATUS                              Status;\r
  EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER WorkingBlockHeader;\r
\r
  ASSERT (WorkingHeader != NULL);\r
  if (WorkingHeader->WorkingBlockValid != FTW_VALID_STATE) {\r
    return FALSE;\r
  }\r
  //\r
  // Check signature with gEfiSystemNvDataFvGuid\r
  //\r
  if (!CompareGuid (&gEfiSystemNvDataFvGuid, &WorkingHeader->Signature)) {\r
    return FALSE;\r
  }\r
  //\r
  // Check the CRC of header\r
  //\r
  CopyMem (\r
    &WorkingBlockHeader,\r
    WorkingHeader,\r
    sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
    );\r
\r
  //\r
  // Filter out the Crc and State fields\r
  //\r
  SetMem (\r
    &WorkingBlockHeader.Crc,\r
    sizeof (UINT32),\r
    FTW_ERASED_BYTE\r
    );\r
  WorkingBlockHeader.WorkingBlockValid    = FTW_ERASE_POLARITY;\r
  WorkingBlockHeader.WorkingBlockInvalid  = FTW_ERASE_POLARITY;\r
\r
  //\r
  // Calculate the Crc of woking block header\r
  //\r
  Status = gBS->CalculateCrc32 (\r
                  (UINT8 *) &WorkingBlockHeader,\r
                  sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
                  &WorkingBlockHeader.Crc\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (WorkingBlockHeader.Crc != WorkingHeader->Crc) {\r
    DEBUG ((EFI_D_FTW_LITE, "FtwLite: Work block header CRC check error\n"));\r
    return FALSE;\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Initialize a work space when there is no work space.\r
\r
\r
  @param WorkingHeader   Pointer of working block header\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
InitWorkSpaceHeader (\r
  IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  ASSERT (WorkingHeader != NULL);\r
\r
  //\r
  // Here using gEfiSystemNvDataFvGuid as the signature.\r
  //\r
  CopyMem (\r
    &WorkingHeader->Signature,\r
    &gEfiSystemNvDataFvGuid,\r
    sizeof (EFI_GUID)\r
    );\r
  WorkingHeader->WriteQueueSize = FTW_WORKING_QUEUE_SIZE;\r
\r
  //\r
  // Crc is calculated with all the fields except Crc and STATE\r
  //\r
  WorkingHeader->WorkingBlockValid    = FTW_ERASE_POLARITY;\r
  WorkingHeader->WorkingBlockInvalid  = FTW_ERASE_POLARITY;\r
  SetMem (&WorkingHeader->Crc, sizeof (UINT32), FTW_ERASED_BYTE);\r
\r
  //\r
  // Calculate the CRC value\r
  //\r
  Status = gBS->CalculateCrc32 (\r
                  (UINT8 *) WorkingHeader,\r
                  sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
                  &WorkingHeader->Crc\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Restore the WorkingBlockValid flag to VALID state\r
  //\r
  WorkingHeader->WorkingBlockValid    = FTW_VALID_STATE;\r
  WorkingHeader->WorkingBlockInvalid  = FTW_INVALID_STATE;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Update a bit of state on a block device. The location of the bit is\r
  calculated by the (Lba, Offset, bit). Here bit is determined by the\r
  the name of a certain bit.\r
\r
\r
  @param FvBlock         FVB Protocol interface to access SrcBlock and DestBlock\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
\r
  @retval  EFI_SUCCESS    A state bit has been updated successfully\r
  @retval  Others         Access block device error.\r
                          Notes:\r
                          Assume all bits of State are inside the same BYTE.\r
  @retval  EFI_ABORTED    Read block fail\r
\r
**/\r
EFI_STATUS\r
FtwUpdateFvState (\r
  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *FvBlock,\r
  IN EFI_LBA                             Lba,\r
  IN UINTN                               Offset,\r
  IN UINT8                               NewBit\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT8       State;\r
  UINTN       Length;\r
\r
  //\r
  // Read state from device, assume State is only one byte.\r
  //\r
  Length  = sizeof (UINT8);\r
  Status  = FvBlock->Read (FvBlock, Lba, Offset, &Length, &State);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  State ^= FTW_POLARITY_REVERT;\r
  State = (UINT8) (State | NewBit);\r
  State ^= FTW_POLARITY_REVERT;\r
\r
  //\r
  // Write state back to device\r
  //\r
  Length  = sizeof (UINT8);\r
  Status  = FvBlock->Write (FvBlock, Lba, Offset, &Length, &State);\r
\r
  return Status;\r
}\r
\r
/**\r
  Get the last Write record pointer.\r
  The last record is the record whose 'complete' state hasn't been set.\r
  After all, this header may be a EMPTY header entry for next Allocate.\r
\r
\r
  @param FtwLiteDevice   Private data of this driver\r
  @param FtwLastRecord   Pointer to retrieve the last write record\r
\r
  @retval  EFI_SUCCESS      Get the last write record successfully\r
  @retval  EFI_ABORTED      The FTW work space is damaged\r
\r
**/\r
EFI_STATUS\r
FtwGetLastRecord (\r
  IN  EFI_FTW_LITE_DEVICE  *FtwLiteDevice,\r
  OUT EFI_FTW_LITE_RECORD  **FtwLastRecord\r
  )\r
{\r
  EFI_FTW_LITE_RECORD *Record;\r
\r
  *FtwLastRecord = NULL;\r
  Record = (EFI_FTW_LITE_RECORD *) (FtwLiteDevice->FtwWorkSpaceHeader + 1);\r
  while (Record->WriteCompleted == FTW_VALID_STATE) {\r
    //\r
    // If Offset exceed the FTW work space boudary, return error.\r
    //\r
    if ((UINTN) ((UINT8 *) Record - FtwLiteDevice->FtwWorkSpace) > FtwLiteDevice->FtwWorkSpaceSize) {\r
      return EFI_ABORTED;\r
    }\r
\r
    Record++;\r
  }\r
  //\r
  // Last write record is found\r
  //\r
  *FtwLastRecord = Record;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Read from working block to refresh the work space in memory.\r
\r
\r
  @param FtwLiteDevice   Point to private data of FTW driver\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
WorkSpaceRefresh (\r
  IN EFI_FTW_LITE_DEVICE  *FtwLiteDevice\r
  )\r
{\r
  EFI_STATUS          Status;\r
  UINTN               Length;\r
  UINTN               Offset;\r
  EFI_FTW_LITE_RECORD *Record;\r
\r
  //\r
  // Initialize WorkSpace as FTW_ERASED_BYTE\r
  //\r
  SetMem (\r
    FtwLiteDevice->FtwWorkSpace,\r
    FtwLiteDevice->FtwWorkSpaceSize,\r
    FTW_ERASED_BYTE\r
    );\r
\r
  //\r
  // Read from working block\r
  //\r
  Length = FtwLiteDevice->FtwWorkSpaceSize;\r
  Status = FtwLiteDevice->FtwFvBlock->Read (\r
                                        FtwLiteDevice->FtwFvBlock,\r
                                        FtwLiteDevice->FtwWorkSpaceLba,\r
                                        FtwLiteDevice->FtwWorkSpaceBase,\r
                                        &Length,\r
                                        FtwLiteDevice->FtwWorkSpace\r
                                        );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  // Refresh the FtwLastRecord\r
  //\r
  Status  = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
\r
  Record  = FtwLiteDevice->FtwLastRecord;\r
  Offset  = (UINTN) (UINT8 *) Record - (UINTN) FtwLiteDevice->FtwWorkSpace;\r
\r
  //\r
  // IF work space has error or Record is out of the workspace limit, THEN\r
  //   call reclaim.\r
  //\r
  if (EFI_ERROR (Status) || (Offset + WRITE_TOTAL_SIZE >= FtwLiteDevice->FtwWorkSpaceSize)) {\r
    //\r
    // reclaim work space in working block.\r
    //\r
    Status = FtwReclaimWorkSpace (FtwLiteDevice, TRUE);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_FTW_LITE, "FtwLite: Reclaim workspace - %r\n", Status));\r
      return EFI_ABORTED;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Reclaim the work space on the working block.\r
\r
\r
  @param FtwLiteDevice   Point to private data of FTW driver\r
\r
  @retval  EFI_SUCCESS            The function completed successfully\r
  @retval  EFI_OUT_OF_RESOURCES   Allocate memory error\r
  @retval  EFI_ABORTED            The function could not complete successfully\r
\r
**/\r
EFI_STATUS\r
FtwReclaimWorkSpace (\r
  IN EFI_FTW_LITE_DEVICE  *FtwLiteDevice,\r
  IN BOOLEAN              PreserveRecord\r
  )\r
{\r
  EFI_STATUS                              Status;\r
  UINT8                                   *TempBuffer;\r
  UINTN                                   TempBufferSize;\r
  UINT8                                   *Ptr;\r
  UINTN                                   Length;\r
  UINTN                                   Index;\r
  UINTN                                   SpareBufferSize;\r
  UINT8                                   *SpareBuffer;\r
  EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader;\r
  EFI_FTW_LITE_RECORD                     *Record;\r
\r
  DEBUG ((EFI_D_FTW_LITE, "FtwLite: start to reclaim work space\n"));\r
\r
  //\r
  // Read all original data from working block to a memory buffer\r
  //\r
  TempBufferSize = FtwLiteDevice->SpareAreaLength;\r
  TempBuffer     = AllocateZeroPool (TempBufferSize);\r
  if (TempBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Ptr = TempBuffer;\r
  for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwLiteDevice->SizeOfSpareBlock;\r
    Status = FtwLiteDevice->FtwFvBlock->Read (\r
                                          FtwLiteDevice->FtwFvBlock,\r
                                          FtwLiteDevice->FtwWorkBlockLba + Index,\r
                                          0,\r
                                          &Length,\r
                                          Ptr\r
                                          );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
  //\r
  // Clean up the workspace, remove all the completed records.\r
  //\r
  Ptr = TempBuffer +\r
    ((UINTN) (FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba)) *\r
    FtwLiteDevice->SizeOfSpareBlock + FtwLiteDevice->FtwWorkSpaceBase;\r
\r
  //\r
  // Clear the content of buffer that will save the new work space data\r
  //\r
  SetMem (Ptr, FtwLiteDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE);\r
\r
  //\r
  // Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer\r
  //\r
  CopyMem (\r
    Ptr,\r
    FtwLiteDevice->FtwWorkSpaceHeader,\r
    sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
    );\r
  if (PreserveRecord) {\r
    //\r
    // Get the last record\r
    //\r
    Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
    Record = FtwLiteDevice->FtwLastRecord;\r
    if (!EFI_ERROR (Status)                       &&\r
        Record                 != NULL            &&\r
        Record->WriteAllocated == FTW_VALID_STATE &&\r
        Record->WriteCompleted != FTW_VALID_STATE) {\r
      CopyMem (\r
        (UINT8 *) Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
        Record,\r
        WRITE_TOTAL_SIZE\r
        );\r
    }\r
  }\r
\r
  CopyMem (\r
    FtwLiteDevice->FtwWorkSpace,\r
    Ptr,\r
    FtwLiteDevice->FtwWorkSpaceSize\r
    );\r
\r
  Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
\r
  //\r
  // Set the WorkingBlockValid and WorkingBlockInvalid as INVALID\r
  //\r
  WorkingBlockHeader                      = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) Ptr;\r
  WorkingBlockHeader->WorkingBlockValid   = FTW_INVALID_STATE;\r
  WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
\r
  //\r
  // Try to keep the content of spare block\r
  // Save spare block into a spare backup memory buffer (Sparebuffer)\r
  //\r
  SpareBufferSize = FtwLiteDevice->SpareAreaLength;\r
  SpareBuffer     = AllocatePool (SpareBufferSize);\r
  if (SpareBuffer == NULL) {\r
    FreePool (TempBuffer);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Ptr = SpareBuffer;\r
  for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwLiteDevice->SizeOfSpareBlock;\r
    Status = FtwLiteDevice->FtwBackupFvb->Read (\r
                                            FtwLiteDevice->FtwBackupFvb,\r
                                            FtwLiteDevice->FtwSpareLba + Index,\r
                                            0,\r
                                            &Length,\r
                                            Ptr\r
                                            );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
  //\r
  // Write the memory buffer to spare block\r
  //\r
  Status  = FtwEraseSpareBlock (FtwLiteDevice);\r
  Ptr     = TempBuffer;\r
  for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwLiteDevice->SizeOfSpareBlock;\r
    Status = FtwLiteDevice->FtwBackupFvb->Write (\r
                                            FtwLiteDevice->FtwBackupFvb,\r
                                            FtwLiteDevice->FtwSpareLba + Index,\r
                                            0,\r
                                            &Length,\r
                                            Ptr\r
                                            );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
  //\r
  // Free TempBuffer\r
  //\r
  FreePool (TempBuffer);\r
\r
  //\r
  // Write the spare block to working block\r
  //\r
  Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SpareBuffer);\r
    return Status;\r
  }\r
  //\r
  // Restore spare backup buffer into spare block , if no failure happened during FtwWrite.\r
  //\r
  Status  = FtwEraseSpareBlock (FtwLiteDevice);\r
  Ptr     = SpareBuffer;\r
  for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwLiteDevice->SizeOfSpareBlock;\r
    Status = FtwLiteDevice->FtwBackupFvb->Write (\r
                                            FtwLiteDevice->FtwBackupFvb,\r
                                            FtwLiteDevice->FtwSpareLba + Index,\r
                                            0,\r
                                            &Length,\r
                                            Ptr\r
                                            );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
\r
  FreePool (SpareBuffer);\r
\r
  DEBUG ((EFI_D_FTW_LITE, "FtwLite: reclaim work space success\n"));\r
\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
6cc9ca32	1	/** @file\r
d7dec593	2	\r
6cc9ca32 LG	3	Internal functions to operate Working Block Space.\r
	4	\r
	5	Copyright (c) 2006 - 2008, Intel Corporation \r
d7dec593	6	All rights reserved. This program and the accompanying materials \r
	7	are licensed and made available under the terms and conditions of the BSD License \r
	8	which accompanies this distribution. The full text of the license may be found at \r
	9	http://opensource.org/licenses/bsd-license.php \r
	10	\r
	11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	13	\r
6cc9ca32	14	**/\r
d7dec593	15	\r
	16	\r
	17	#include <FtwLite.h>\r
	18	\r
6aab8214	19	/**\r
6aab8214	20	Check to see if it is a valid work space.\r
d7dec593	21	\r
d7dec593	22	\r
6aab8214	23	@param WorkingHeader Pointer of working block header\r
d7dec593	24	\r
6aab8214	25	@retval EFI_SUCCESS The function completed successfully\r
6aab8214	26	@retval EFI_ABORTED The function could not complete successfully.\r
d7dec593	27	\r
6aab8214	28	**/\r
	29	BOOLEAN\r
	30	IsValidWorkSpace (\r
	31	IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
	32	)\r
d7dec593	33	{\r
	34	EFI_STATUS Status;\r
	35	EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER WorkingBlockHeader;\r
	36	\r
	37	ASSERT (WorkingHeader != NULL);\r
	38	if (WorkingHeader->WorkingBlockValid != FTW_VALID_STATE) {\r
	39	return FALSE;\r
	40	}\r
	41	//\r
	42	// Check signature with gEfiSystemNvDataFvGuid\r
	43	//\r
	44	if (!CompareGuid (&gEfiSystemNvDataFvGuid, &WorkingHeader->Signature)) {\r
	45	return FALSE;\r
	46	}\r
	47	//\r
	48	// Check the CRC of header\r
	49	//\r
	50	CopyMem (\r
	51	&WorkingBlockHeader,\r
	52	WorkingHeader,\r
	53	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
	54	);\r
	55	\r
	56	//\r
	57	// Filter out the Crc and State fields\r
	58	//\r
	59	SetMem (\r
	60	&WorkingBlockHeader.Crc,\r
	61	sizeof (UINT32),\r
	62	FTW_ERASED_BYTE\r
	63	);\r
	64	WorkingBlockHeader.WorkingBlockValid = FTW_ERASE_POLARITY;\r
	65	WorkingBlockHeader.WorkingBlockInvalid = FTW_ERASE_POLARITY;\r
	66	\r
	67	//\r
	68	// Calculate the Crc of woking block header\r
	69	//\r
	70	Status = gBS->CalculateCrc32 (\r
	71	(UINT8 *) &WorkingBlockHeader,\r
	72	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
	73	&WorkingBlockHeader.Crc\r
	74	);\r
	75	ASSERT_EFI_ERROR (Status);\r
	76	\r
	77	if (WorkingBlockHeader.Crc != WorkingHeader->Crc) {\r
	78	DEBUG ((EFI_D_FTW_LITE, "FtwLite: Work block header CRC check error\n"));\r
	79	return FALSE;\r
	80	}\r
	81	\r
	82	return TRUE;\r
	83	}\r
	84	\r
6aab8214	85	/**\r
6aab8214	86	Initialize a work space when there is no work space.\r
d7dec593	87	\r
d7dec593	88	\r
6aab8214	89	@param WorkingHeader Pointer of working block header\r
d7dec593	90	\r
6aab8214	91	@retval EFI_SUCCESS The function completed successfully\r
6aab8214	92	@retval EFI_ABORTED The function could not complete successfully.\r
d7dec593	93	\r
6aab8214	94	**/\r
	95	EFI_STATUS\r
	96	InitWorkSpaceHeader (\r
	97	IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
	98	)\r
d7dec593	99	{\r
	100	EFI_STATUS Status;\r
	101	\r
	102	ASSERT (WorkingHeader != NULL);\r
	103	\r
	104	//\r
	105	// Here using gEfiSystemNvDataFvGuid as the signature.\r
	106	//\r
	107	CopyMem (\r
	108	&WorkingHeader->Signature,\r
	109	&gEfiSystemNvDataFvGuid,\r
	110	sizeof (EFI_GUID)\r
	111	);\r
	112	WorkingHeader->WriteQueueSize = FTW_WORKING_QUEUE_SIZE;\r
	113	\r
	114	//\r
	115	// Crc is calculated with all the fields except Crc and STATE\r
	116	//\r
	117	WorkingHeader->WorkingBlockValid = FTW_ERASE_POLARITY;\r
	118	WorkingHeader->WorkingBlockInvalid = FTW_ERASE_POLARITY;\r
	119	SetMem (&WorkingHeader->Crc, sizeof (UINT32), FTW_ERASED_BYTE);\r
	120	\r
	121	//\r
	122	// Calculate the CRC value\r
	123	//\r
	124	Status = gBS->CalculateCrc32 (\r
	125	(UINT8 *) WorkingHeader,\r
	126	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
	127	&WorkingHeader->Crc\r
	128	);\r
	129	ASSERT_EFI_ERROR (Status);\r
	130	\r
	131	//\r
	132	// Restore the WorkingBlockValid flag to VALID state\r
	133	//\r
	134	WorkingHeader->WorkingBlockValid = FTW_VALID_STATE;\r
	135	WorkingHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
	136	\r
	137	return EFI_SUCCESS;\r
	138	}\r
	139	\r
6aab8214	140	/**\r
	141	Update a bit of state on a block device. The location of the bit is\r
	142	calculated by the (Lba, Offset, bit). Here bit is determined by the\r
	143	the name of a certain bit.\r
	144	\r
	145	\r
	146	@param FvBlock FVB Protocol interface to access SrcBlock and DestBlock\r
	147	@param Lba Lba of a block\r
	148	@param Offset Offset on the Lba\r
	149	@param NewBit New value that will override the old value if it can be change\r
	150	\r
	151	@retval EFI_SUCCESS A state bit has been updated successfully\r
	152	@retval Others Access block device error.\r
	153	Notes:\r
	154	Assume all bits of State are inside the same BYTE.\r
	155	@retval EFI_ABORTED Read block fail\r
	156	\r
	157	**/\r
d7dec593	158	EFI_STATUS\r
	159	FtwUpdateFvState (\r
	160	IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
	161	IN EFI_LBA Lba,\r
	162	IN UINTN Offset,\r
	163	IN UINT8 NewBit\r
	164	)\r
d7dec593	165	{\r
	166	EFI_STATUS Status;\r
	167	UINT8 State;\r
	168	UINTN Length;\r
	169	\r
	170	//\r
	171	// Read state from device, assume State is only one byte.\r
	172	//\r
	173	Length = sizeof (UINT8);\r
	174	Status = FvBlock->Read (FvBlock, Lba, Offset, &Length, &State);\r
	175	if (EFI_ERROR (Status)) {\r
	176	return EFI_ABORTED;\r
	177	}\r
	178	\r
	179	State ^= FTW_POLARITY_REVERT;\r
	180	State = (UINT8) (State \| NewBit);\r
	181	State ^= FTW_POLARITY_REVERT;\r
	182	\r
	183	//\r
	184	// Write state back to device\r
	185	//\r
	186	Length = sizeof (UINT8);\r
	187	Status = FvBlock->Write (FvBlock, Lba, Offset, &Length, &State);\r
	188	\r
	189	return Status;\r
	190	}\r
	191	\r
6aab8214	192	/**\r
	193	Get the last Write record pointer.\r
	194	The last record is the record whose 'complete' state hasn't been set.\r
	195	After all, this header may be a EMPTY header entry for next Allocate.\r
	196	\r
	197	\r
	198	@param FtwLiteDevice Private data of this driver\r
	199	@param FtwLastRecord Pointer to retrieve the last write record\r
	200	\r
	201	@retval EFI_SUCCESS Get the last write record successfully\r
	202	@retval EFI_ABORTED The FTW work space is damaged\r
	203	\r
	204	**/\r
d7dec593	205	EFI_STATUS\r
	206	FtwGetLastRecord (\r
	207	IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,\r
	208	OUT EFI_FTW_LITE_RECORD **FtwLastRecord\r
	209	)\r
d7dec593	210	{\r
	211	EFI_FTW_LITE_RECORD *Record;\r
	212	\r
e11ae3a5	213	*FtwLastRecord = NULL;\r
d7dec593	214	Record = (EFI_FTW_LITE_RECORD *) (FtwLiteDevice->FtwWorkSpaceHeader + 1);\r
	215	while (Record->WriteCompleted == FTW_VALID_STATE) {\r
	216	//\r
	217	// If Offset exceed the FTW work space boudary, return error.\r
	218	//\r
	219	if ((UINTN) ((UINT8 *) Record - FtwLiteDevice->FtwWorkSpace) > FtwLiteDevice->FtwWorkSpaceSize) {\r
	220	return EFI_ABORTED;\r
	221	}\r
	222	\r
	223	Record++;\r
	224	}\r
	225	//\r
	226	// Last write record is found\r
	227	//\r
	228	*FtwLastRecord = Record;\r
	229	return EFI_SUCCESS;\r
	230	}\r
	231	\r
6aab8214	232	/**\r
6aab8214	233	Read from working block to refresh the work space in memory.\r
d7dec593	234	\r
d7dec593	235	\r
6aab8214	236	@param FtwLiteDevice Point to private data of FTW driver\r
d7dec593	237	\r
6aab8214	238	@retval EFI_SUCCESS The function completed successfully\r
6aab8214	239	@retval EFI_ABORTED The function could not complete successfully.\r
d7dec593	240	\r
6aab8214	241	**/\r
	242	EFI_STATUS\r
	243	WorkSpaceRefresh (\r
	244	IN EFI_FTW_LITE_DEVICE *FtwLiteDevice\r
	245	)\r
d7dec593	246	{\r
	247	EFI_STATUS Status;\r
	248	UINTN Length;\r
	249	UINTN Offset;\r
	250	EFI_FTW_LITE_RECORD *Record;\r
	251	\r
	252	//\r
	253	// Initialize WorkSpace as FTW_ERASED_BYTE\r
	254	//\r
	255	SetMem (\r
	256	FtwLiteDevice->FtwWorkSpace,\r
	257	FtwLiteDevice->FtwWorkSpaceSize,\r
	258	FTW_ERASED_BYTE\r
	259	);\r
	260	\r
	261	//\r
	262	// Read from working block\r
	263	//\r
	264	Length = FtwLiteDevice->FtwWorkSpaceSize;\r
	265	Status = FtwLiteDevice->FtwFvBlock->Read (\r
	266	FtwLiteDevice->FtwFvBlock,\r
	267	FtwLiteDevice->FtwWorkSpaceLba,\r
	268	FtwLiteDevice->FtwWorkSpaceBase,\r
	269	&Length,\r
	270	FtwLiteDevice->FtwWorkSpace\r
	271	);\r
	272	if (EFI_ERROR (Status)) {\r
	273	return EFI_ABORTED;\r
	274	}\r
	275	//\r
	276	// Refresh the FtwLastRecord\r
	277	//\r
	278	Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
	279	\r
	280	Record = FtwLiteDevice->FtwLastRecord;\r
	281	Offset = (UINTN) (UINT8 *) Record - (UINTN) FtwLiteDevice->FtwWorkSpace;\r
	282	\r
	283	//\r
	284	// IF work space has error or Record is out of the workspace limit, THEN\r
	285	// call reclaim.\r
	286	//\r
	287	if (EFI_ERROR (Status) \|\| (Offset + WRITE_TOTAL_SIZE >= FtwLiteDevice->FtwWorkSpaceSize)) {\r
	288	//\r
	289	// reclaim work space in working block.\r
	290	//\r
e11ae3a5	291	Status = FtwReclaimWorkSpace (FtwLiteDevice, TRUE);\r
d7dec593	292	if (EFI_ERROR (Status)) {\r
	293	DEBUG ((EFI_D_FTW_LITE, "FtwLite: Reclaim workspace - %r\n", Status));\r
	294	return EFI_ABORTED;\r
	295	}\r
	296	}\r
	297	\r
	298	return EFI_SUCCESS;\r
	299	}\r
	300	\r
6aab8214	301	/**\r
6aab8214	302	Reclaim the work space on the working block.\r
d7dec593	303	\r
d7dec593	304	\r
6aab8214	305	@param FtwLiteDevice Point to private data of FTW driver\r
d7dec593	306	\r
6aab8214	307	@retval EFI_SUCCESS The function completed successfully\r
	308	@retval EFI_OUT_OF_RESOURCES Allocate memory error\r
	309	@retval EFI_ABORTED The function could not complete successfully\r
d7dec593	310	\r
6aab8214	311	**/\r
	312	EFI_STATUS\r
	313	FtwReclaimWorkSpace (\r
e11ae3a5 LG	314	IN EFI_FTW_LITE_DEVICE *FtwLiteDevice,\r
e11ae3a5 LG	315	IN BOOLEAN PreserveRecord\r
6aab8214	316	)\r
d7dec593	317	{\r
	318	EFI_STATUS Status;\r
	319	UINT8 *TempBuffer;\r
	320	UINTN TempBufferSize;\r
	321	UINT8 *Ptr;\r
	322	UINTN Length;\r
	323	UINTN Index;\r
	324	UINTN SpareBufferSize;\r
	325	UINT8 *SpareBuffer;\r
	326	EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader;\r
e11ae3a5	327	EFI_FTW_LITE_RECORD *Record;\r
d7dec593	328	\r
	329	DEBUG ((EFI_D_FTW_LITE, "FtwLite: start to reclaim work space\n"));\r
	330	\r
	331	//\r
	332	// Read all original data from working block to a memory buffer\r
	333	//\r
	334	TempBufferSize = FtwLiteDevice->SpareAreaLength;\r
	335	TempBuffer = AllocateZeroPool (TempBufferSize);\r
e11ae3a5	336	if (TempBuffer == NULL) {\r
d7dec593	337	return EFI_OUT_OF_RESOURCES;\r
	338	}\r
	339	\r
	340	Ptr = TempBuffer;\r
	341	for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
	342	Length = FtwLiteDevice->SizeOfSpareBlock;\r
	343	Status = FtwLiteDevice->FtwFvBlock->Read (\r
	344	FtwLiteDevice->FtwFvBlock,\r
	345	FtwLiteDevice->FtwWorkBlockLba + Index,\r
	346	0,\r
	347	&Length,\r
	348	Ptr\r
	349	);\r
	350	if (EFI_ERROR (Status)) {\r
	351	FreePool (TempBuffer);\r
	352	return EFI_ABORTED;\r
	353	}\r
	354	\r
	355	Ptr += Length;\r
	356	}\r
	357	//\r
	358	// Clean up the workspace, remove all the completed records.\r
	359	//\r
	360	Ptr = TempBuffer +\r
	361	((UINTN) (FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba)) *\r
	362	FtwLiteDevice->SizeOfSpareBlock + FtwLiteDevice->FtwWorkSpaceBase;\r
	363	\r
e11ae3a5 LG	364	//\r
	365	// Clear the content of buffer that will save the new work space data\r
	366	//\r
	367	SetMem (Ptr, FtwLiteDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE);\r
	368	\r
	369	//\r
	370	// Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer\r
	371	//\r
	372	CopyMem (\r
	373	Ptr,\r
	374	FtwLiteDevice->FtwWorkSpaceHeader,\r
	375	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
	376	);\r
	377	if (PreserveRecord) {\r
	378	//\r
	379	// Get the last record\r
	380	//\r
	381	Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
	382	Record = FtwLiteDevice->FtwLastRecord;\r
	383	if (!EFI_ERROR (Status) &&\r
	384	Record != NULL &&\r
	385	Record->WriteAllocated == FTW_VALID_STATE &&\r
	386	Record->WriteCompleted != FTW_VALID_STATE) {\r
	387	CopyMem (\r
	388	(UINT8 *) Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
	389	Record,\r
	390	WRITE_TOTAL_SIZE\r
	391	);\r
	392	}\r
	393	}\r
d7dec593	394	\r
	395	CopyMem (\r
	396	FtwLiteDevice->FtwWorkSpace,\r
	397	Ptr,\r
	398	FtwLiteDevice->FtwWorkSpaceSize\r
	399	);\r
	400	\r
	401	Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord);\r
	402	\r
	403	//\r
	404	// Set the WorkingBlockValid and WorkingBlockInvalid as INVALID\r
	405	//\r
	406	WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) Ptr;\r
	407	WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE;\r
	408	WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
	409	\r
	410	//\r
	411	// Try to keep the content of spare block\r
	412	// Save spare block into a spare backup memory buffer (Sparebuffer)\r
	413	//\r
	414	SpareBufferSize = FtwLiteDevice->SpareAreaLength;\r
	415	SpareBuffer = AllocatePool (SpareBufferSize);\r
	416	if (SpareBuffer == NULL) {\r
	417	FreePool (TempBuffer);\r
	418	return EFI_OUT_OF_RESOURCES;\r
	419	}\r
	420	\r
	421	Ptr = SpareBuffer;\r
	422	for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
	423	Length = FtwLiteDevice->SizeOfSpareBlock;\r
	424	Status = FtwLiteDevice->FtwBackupFvb->Read (\r
	425	FtwLiteDevice->FtwBackupFvb,\r
	426	FtwLiteDevice->FtwSpareLba + Index,\r
	427	0,\r
	428	&Length,\r
	429	Ptr\r
	430	);\r
	431	if (EFI_ERROR (Status)) {\r
	432	FreePool (TempBuffer);\r
	433	FreePool (SpareBuffer);\r
	434	return EFI_ABORTED;\r
	435	}\r
	436	\r
	437	Ptr += Length;\r
	438	}\r
	439	//\r
	440	// Write the memory buffer to spare block\r
	441	//\r
	442	Status = FtwEraseSpareBlock (FtwLiteDevice);\r
	443	Ptr = TempBuffer;\r
	444	for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
	445	Length = FtwLiteDevice->SizeOfSpareBlock;\r
	446	Status = FtwLiteDevice->FtwBackupFvb->Write (\r
	447	FtwLiteDevice->FtwBackupFvb,\r
	448	FtwLiteDevice->FtwSpareLba + Index,\r
	449	0,\r
	450	&Length,\r
	451	Ptr\r
	452	);\r
	453	if (EFI_ERROR (Status)) {\r
	454	FreePool (TempBuffer);\r
	455	FreePool (SpareBuffer);\r
	456	return EFI_ABORTED;\r
	457	}\r
458	\r
459	Ptr += Length;\r
460	}\r
461	//\r
462	// Free TempBuffer\r
463	//\r
464	FreePool (TempBuffer);\r
465	\r
466	//\r
467	// Write the spare block to working block\r
468	//\r
469	Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice);\r
470	if (EFI_ERROR (Status)) {\r
471	FreePool (SpareBuffer);\r
472	return Status;\r
473	}\r
474	//\r
475	// Restore spare backup buffer into spare block , if no failure happened during FtwWrite.\r
476	//\r
477	Status = FtwEraseSpareBlock (FtwLiteDevice);\r
478	Ptr = SpareBuffer;\r
479	for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) {\r
480	Length = FtwLiteDevice->SizeOfSpareBlock;\r
481	Status = FtwLiteDevice->FtwBackupFvb->Write (\r
482	FtwLiteDevice->FtwBackupFvb,\r
483	FtwLiteDevice->FtwSpareLba + Index,\r
484	0,\r
485	&Length,\r
486	Ptr\r
487	);\r
488	if (EFI_ERROR (Status)) {\r
489	FreePool (SpareBuffer);\r
490	return EFI_ABORTED;\r
491	}\r
492	\r
493	Ptr += Length;\r
494	}\r
495	\r
496	FreePool (SpareBuffer);\r
497	\r
498	DEBUG ((EFI_D_FTW_LITE, "FtwLite: reclaim work space success\n"));\r
499	\r
500	return EFI_SUCCESS;\r
501	}\r