/** @file NorFlashDxe.c\r
\r
- Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>\r
+ Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>\r
\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
- 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
+ SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/PcdLib.h>\r
+#include <Library/HobLib.h>\r
+#include <Library/DxeServicesTableLib.h>\r
\r
-#include "NorFlashDxe.h"\r
+#include "NorFlash.h"\r
\r
+STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;\r
\r
//\r
// Global variable declarations\r
//\r
-NOR_FLASH_INSTANCE **mNorFlashInstances;\r
+NOR_FLASH_INSTANCE **mNorFlashInstances;\r
+UINT32 mNorFlashDeviceCount;\r
+UINTN mFlashNvStorageVariableBase;\r
+EFI_EVENT mFvbVirtualAddrChangeEvent;\r
\r
NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {\r
NOR_FLASH_SIGNATURE, // Signature\r
- NULL, // Handle ... NEED TO BE FILLED\r
-\r
- FALSE, // Initialized\r
- NULL, // Initialize\r
+ NULL, // Handle ... NEED TO BE FILLED\r
\r
0, // DeviceBaseAddress ... NEED TO BE FILLED\r
0, // RegionBaseAddress ... NEED TO BE FILLED\r
\r
{\r
EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision\r
- NULL, // Media ... NEED TO BE FILLED\r
- NorFlashBlockIoReset, // Reset;\r
- NorFlashBlockIoReadBlocks, // ReadBlocks\r
- NorFlashBlockIoWriteBlocks, // WriteBlocks\r
- NorFlashBlockIoFlushBlocks // FlushBlocks\r
+ NULL, // Media ... NEED TO BE FILLED\r
+ NorFlashBlockIoReset, // Reset;\r
+ NorFlashBlockIoReadBlocks, // ReadBlocks\r
+ NorFlashBlockIoWriteBlocks, // WriteBlocks\r
+ NorFlashBlockIoFlushBlocks // FlushBlocks\r
}, // BlockIoProtocol\r
\r
{\r
- 0, // MediaId ... NEED TO BE FILLED\r
+ 0, // MediaId ... NEED TO BE FILLED\r
FALSE, // RemovableMedia\r
- TRUE, // MediaPresent\r
+ TRUE, // MediaPresent\r
FALSE, // LogicalPartition\r
FALSE, // ReadOnly\r
FALSE, // WriteCaching;\r
- 0, // BlockSize ... NEED TO BE FILLED\r
- 4, // IoAlign\r
- 0, // LastBlock ... NEED TO BE FILLED\r
- 0, // LowestAlignedLba\r
- 1, // LogicalBlocksPerPhysicalBlock\r
- }, //Media;\r
-\r
- FALSE, // SupportFvb ... NEED TO BE FILLED\r
+ 0, // BlockSize ... NEED TO BE FILLED\r
+ 4, // IoAlign\r
+ 0, // LastBlock ... NEED TO BE FILLED\r
+ 0, // LowestAlignedLba\r
+ 1, // LogicalBlocksPerPhysicalBlock\r
+ }, // Media;\r
+\r
{\r
- FvbGetAttributes, // GetAttributes\r
- FvbSetAttributes, // SetAttributes\r
- FvbGetPhysicalAddress, // GetPhysicalAddress\r
- FvbGetBlockSize, // GetBlockSize\r
- FvbRead, // Read\r
- FvbWrite, // Write\r
- FvbEraseBlocks, // EraseBlocks\r
- NULL, //ParentHandle\r
- }, // FvbProtoccol;\r
+ EFI_DISK_IO_PROTOCOL_REVISION, // Revision\r
+ NorFlashDiskIoReadDisk, // ReadDisk\r
+ NorFlashDiskIoWriteDisk // WriteDisk\r
+ },\r
\r
+ {\r
+ FvbGetAttributes, // GetAttributes\r
+ FvbSetAttributes, // SetAttributes\r
+ FvbGetPhysicalAddress, // GetPhysicalAddress\r
+ FvbGetBlockSize, // GetBlockSize\r
+ FvbRead, // Read\r
+ FvbWrite, // Write\r
+ FvbEraseBlocks, // EraseBlocks\r
+ NULL, // ParentHandle\r
+ }, // FvbProtoccol;\r
+ NULL, // ShadowBuffer\r
{\r
{\r
{\r
HARDWARE_DEVICE_PATH,\r
HW_VENDOR_DP,\r
- (UINT8)( sizeof(VENDOR_DEVICE_PATH) ),\r
- (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),\r
+ {\r
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),\r
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)\r
+ }\r
},\r
- { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, // GUID ... NEED TO BE FILLED\r
+ { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }\r
+ }, // GUID ... NEED TO BE FILLED\r
},\r
+ 0, // Index\r
{\r
END_DEVICE_PATH_TYPE,\r
END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
- sizeof (EFI_DEVICE_PATH_PROTOCOL),\r
- 0\r
+ { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
}\r
- } // DevicePath\r
+ } // DevicePath\r
};\r
\r
EFI_STATUS\r
NorFlashCreateInstance (\r
- IN UINTN NorFlashDeviceBase,\r
- IN UINTN NorFlashRegionBase,\r
- IN UINTN NorFlashSize,\r
- IN UINT32 MediaId,\r
- IN UINT32 BlockSize,\r
- IN BOOLEAN SupportFvb,\r
- IN CONST GUID *NorFlashGuid,\r
- OUT NOR_FLASH_INSTANCE** NorFlashInstance\r
+ IN UINTN NorFlashDeviceBase,\r
+ IN UINTN NorFlashRegionBase,\r
+ IN UINTN NorFlashSize,\r
+ IN UINT32 Index,\r
+ IN UINT32 BlockSize,\r
+ IN BOOLEAN SupportFvb,\r
+ OUT NOR_FLASH_INSTANCE **NorFlashInstance\r
)\r
{\r
- EFI_STATUS Status;\r
- NOR_FLASH_INSTANCE* Instance;\r
+ EFI_STATUS Status;\r
+ NOR_FLASH_INSTANCE *Instance;\r
\r
- ASSERT(NorFlashInstance != NULL);\r
+ ASSERT (NorFlashInstance != NULL);\r
\r
- Instance = AllocateCopyPool (sizeof(NOR_FLASH_INSTANCE),&mNorFlashInstanceTemplate);\r
+ Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate);\r
if (Instance == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
Instance->DeviceBaseAddress = NorFlashDeviceBase;\r
Instance->RegionBaseAddress = NorFlashRegionBase;\r
- Instance->Size = NorFlashSize;\r
+ Instance->Size = NorFlashSize;\r
\r
Instance->BlockIoProtocol.Media = &Instance->Media;\r
- Instance->Media.MediaId = MediaId;\r
- Instance->Media.BlockSize = BlockSize;\r
- Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
+ Instance->Media.MediaId = Index;\r
+ Instance->Media.BlockSize = BlockSize;\r
+ Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;\r
\r
- CopyGuid (&Instance->DevicePath.Vendor.Guid,NorFlashGuid);\r
+ CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);\r
+ Instance->DevicePath.Index = (UINT8)Index;\r
+\r
+ Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);\r
+ if (Instance->ShadowBuffer == NULL) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
\r
if (SupportFvb) {\r
- Instance->SupportFvb = TRUE;\r
- Instance->Initialize = NorFlashFvbInitialize;\r
+ NorFlashFvbInitialize (Instance);\r
\r
Status = gBS->InstallMultipleProtocolInterfaces (\r
- &Instance->Handle,\r
- &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
- &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,\r
- &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,\r
- NULL\r
- );\r
- if (EFI_ERROR(Status)) {\r
- FreePool(Instance);\r
+ &Instance->Handle,\r
+ &gEfiDevicePathProtocolGuid,\r
+ &Instance->DevicePath,\r
+ &gEfiBlockIoProtocolGuid,\r
+ &Instance->BlockIoProtocol,\r
+ &gEfiFirmwareVolumeBlockProtocolGuid,\r
+ &Instance->FvbProtocol,\r
+ NULL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ FreePool (Instance);\r
return Status;\r
}\r
} else {\r
- Instance->Initialized = TRUE;\r
-\r
Status = gBS->InstallMultipleProtocolInterfaces (\r
&Instance->Handle,\r
- &gEfiDevicePathProtocolGuid, &Instance->DevicePath,\r
- &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,\r
+ &gEfiDevicePathProtocolGuid,\r
+ &Instance->DevicePath,\r
+ &gEfiBlockIoProtocolGuid,\r
+ &Instance->BlockIoProtocol,\r
+ &gEfiDiskIoProtocolGuid,\r
+ &Instance->DiskIoProtocol,\r
NULL\r
);\r
- if (EFI_ERROR(Status)) {\r
- FreePool(Instance);\r
+ if (EFI_ERROR (Status)) {\r
+ FreePool (Instance);\r
return Status;\r
}\r
}\r
return Status;\r
}\r
\r
-UINT32\r
-NorFlashReadStatusRegister (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN SR_Address\r
- )\r
-{\r
- // Prepare to read the status register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);\r
- return MmioRead32 (Instance->DeviceBaseAddress);\r
-}\r
-\r
-\r
-BOOLEAN\r
-NorFlashBlockIsLocked (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- UINT32 LockStatus;\r
- BOOLEAN BlockIsLocked;\r
-\r
- BlockIsLocked = TRUE;\r
-\r
- // Send command for reading device id\r
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);\r
-\r
- // Read block lock status\r
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));\r
-\r
- // Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);\r
-\r
- if ((LockStatus & 0x2) != 0) {\r
- DEBUG((EFI_D_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));\r
- }\r
-\r
- if ((LockStatus & 0x1) == 0) {\r
- // This means the block is unlocked\r
- DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: Block 0x%08x unlocked\n", BlockAddress));\r
- BlockIsLocked = FALSE;\r
- }\r
-\r
- return BlockIsLocked;\r
-}\r
-\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status = EFI_SUCCESS;\r
- UINT32 LockStatus;\r
-\r
- // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations\r
- // and to protect shared data structures.\r
-\r
- if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {\r
- do {\r
- // Request a lock setup\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);\r
-\r
- // Request an unlock\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);\r
-\r
- // Send command for reading device id\r
- SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);\r
-\r
- // Read block lock status\r
- LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));\r
-\r
- // Decode block lock status\r
- LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);\r
- } while ((LockStatus & 0x1) == 1);\r
- } else {\r
- // Request a lock setup\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);\r
-\r
- // Request an unlock\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);\r
-\r
- // Wait until the status register gives us the all clear\r
- do {\r
- LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);\r
- } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x, Exit Status = \"%r\".\n", BlockAddress, Status));\r
-\r
- return Status;\r
-}\r
-\r
-\r
-EFI_STATUS\r
-NorFlashUnlockSingleBlockIfNecessary (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status = EFI_SUCCESS;\r
-\r
- if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {\r
- Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-\r
-/**\r
- * The following function presumes that the block has already been unlocked.\r
- **/\r
-EFI_STATUS\r
-NorFlashEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Request a block erase and then confirm it\r
- SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);\r
- SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);\r
-\r
- // Wait until the status register gives us the all clear\r
- do {\r
- StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {\r
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_ERASE) {\r
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...\r
- DEBUG((EFI_D_INFO,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));\r
- Status = EFI_WRITE_PROTECTED;\r
- }\r
-\r
- if (EFI_ERROR(Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- return Status;\r
-}\r
-\r
/**\r
- * The following function presumes that the block has already been unlocked.\r
+ * This function unlock and erase an entire NOR Flash block.\r
**/\r
EFI_STATUS\r
NorFlashUnlockAndEraseSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN BlockAddress\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN UINTN BlockAddress\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN Index;\r
- EFI_TPL OriginalTPL;\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ EFI_TPL OriginalTPL;\r
\r
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ if (!EfiAtRuntime ()) {\r
+ // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
+ OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ } else {\r
+ // This initialization is only to prevent the compiler to complain about the\r
+ // use of uninitialized variables\r
+ OriginalTPL = TPL_HIGH_LEVEL;\r
+ }\r
\r
Index = 0;\r
// The block erase might fail a first time (SW bug ?). Retry it ...\r
do {\r
// Unlock the block if we have to\r
Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);\r
- if (!EFI_ERROR(Status)) {\r
- Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
+ if (EFI_ERROR (Status)) {\r
+ break;\r
}\r
+\r
+ Status = NorFlashEraseSingleBlock (Instance, BlockAddress);\r
Index++;\r
} while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));\r
\r
if (Index == NOR_FLASH_ERASE_RETRY) {\r
- DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress,Index));\r
+ DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index));\r
}\r
\r
- // Interruptions can resume.\r
- gBS->RestoreTPL (OriginalTPL);\r
-\r
- return Status;\r
-}\r
-\r
-\r
-EFI_STATUS\r
-NorFlashWriteSingleWord (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN WordAddress,\r
- IN UINT32 WriteData\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 StatusRegister;\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- // Request a write single word command\r
- SEND_NOR_COMMAND(WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);\r
-\r
- // Store the word into NOR Flash;\r
- MmioWrite32 (WordAddress, WriteData);\r
-\r
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register\r
- do {\r
- // Prepare to read the status register\r
- StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);\r
- // The chip is busy while the WRITE bit is not asserted\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
-\r
- // Perform a full status check:\r
- // Mask the relevant bits of Status Register.\r
- // Everything should be zero, if not, we have a problem\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_PROGRAM) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",WordAddress));\r
- Status = EFI_DEVICE_ERROR;\r
+ if (!EfiAtRuntime ()) {\r
+ // Interruptions can resume.\r
+ gBS->RestoreTPL (OriginalTPL);\r
}\r
\r
- if (!EFI_ERROR(Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
return Status;\r
}\r
\r
-/*\r
- * Writes data to the NOR Flash using the Buffered Programming method.\r
- *\r
- * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.\r
- * Therefore this function will only handle buffers up to 32 words or 128 bytes.\r
- * To deal with larger buffers, call this function again.\r
- *\r
- * This function presumes that both the TargetAddress and the TargetAddress+BufferSize\r
- * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.\r
- *\r
- * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,\r
- * then programming time is doubled and power consumption is increased.\r
- * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.\r
- * i.e. the last 4 bits of the target start address must be zero: 0x......00\r
- */\r
EFI_STATUS\r
-NorFlashWriteBuffer (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN UINTN TargetAddress,\r
- IN UINTN BufferSizeInBytes,\r
- IN UINT32 *Buffer\r
+NorFlashWriteFullBlock (\r
+ IN NOR_FLASH_INSTANCE *Instance,\r
+ IN EFI_LBA Lba,\r
+ IN UINT32 *DataBuffer,\r
+ IN UINT32 BlockSizeInWords\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN BufferSizeInWords;\r
- UINTN Count;\r
- volatile UINT32 *Data;\r
- UINTN WaitForBuffer;\r
- BOOLEAN BufferAvailable;\r
- UINT32 StatusRegister;\r
-\r
- WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS;\r
- BufferAvailable = FALSE;\r
-\r
- // Check that the target address does not cross a 32-word boundary.\r
- if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Check there are some data to program\r
- if (BufferSizeInBytes == 0) {\r
- return EFI_BUFFER_TOO_SMALL;\r
- }\r
-\r
- // Check that the buffer size does not exceed the maximum hardware buffer size on chip.\r
- if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Check that the buffer size is a multiple of 32-bit words\r
- if ((BufferSizeInBytes % 4) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // Pre-programming conditions checked, now start the algorithm.\r
-\r
- // Prepare the data destination address\r
- Data = (UINT32 *)TargetAddress;\r
-\r
- // Check the availability of the buffer\r
- do {\r
- // Issue the Buffered Program Setup command\r
- SEND_NOR_COMMAND(TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);\r
-\r
- // Read back the status register bit#7 from the same address\r
- if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {\r
- BufferAvailable = TRUE;\r
- }\r
-\r
- // Update the loop counter\r
- WaitForBuffer--;\r
-\r
- } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));\r
-\r
- // The buffer was not available for writing\r
- if (WaitForBuffer == 0) {\r
- Status = EFI_DEVICE_ERROR;\r
- goto EXIT;\r
- }\r
-\r
- // From now on we work in 32-bit words\r
- BufferSizeInWords = BufferSizeInBytes / (UINTN)4;\r
-\r
- // Write the word count, which is (buffer_size_in_words - 1),\r
- // because word count 0 means one word.\r
- SEND_NOR_COMMAND(TargetAddress, 0, (BufferSizeInWords - 1));\r
-\r
- // Write the data to the NOR Flash, advancing each address by 4 bytes\r
- for(Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {\r
- *Data = *Buffer;\r
- }\r
-\r
- // Issue the Buffered Program Confirm command, to start the programming operation\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);\r
-\r
- // Wait for the write to complete and then check for any errors; i.e. check the Status Register\r
- do {\r
- StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);\r
- // The chip is busy while the WRITE bit is not asserted\r
- } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);\r
-\r
-\r
- // Perform a full status check:\r
- // Mask the relevant bits of Status Register.\r
- // Everything should be zero, if not, we have a problem\r
-\r
- Status = EFI_SUCCESS;\r
-\r
- if (StatusRegister & P30_SR_BIT_VPP) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_PROGRAM) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {\r
- DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n",TargetAddress));\r
- Status = EFI_DEVICE_ERROR;\r
- }\r
-\r
- if (!EFI_ERROR(Status)) {\r
- // Clear the Status Register\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);\r
- }\r
-\r
-EXIT:\r
- // Put device back into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-NorFlashWriteSingleBlock (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINT32 *DataBuffer,\r
- IN UINT32 BlockSizeInWords\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINTN WordAddress;\r
- UINT32 WordIndex;\r
- UINTN BufferIndex;\r
- UINTN BlockAddress;\r
- UINTN BuffersInBlock;\r
- UINTN RemainingWords;\r
- EFI_TPL OriginalTPL;\r
+ EFI_STATUS Status;\r
+ UINTN WordAddress;\r
+ UINT32 WordIndex;\r
+ UINTN BufferIndex;\r
+ UINTN BlockAddress;\r
+ UINTN BuffersInBlock;\r
+ UINTN RemainingWords;\r
+ EFI_TPL OriginalTPL;\r
+ UINTN Cnt;\r
\r
Status = EFI_SUCCESS;\r
\r
// Start writing from the first address at the start of the block\r
WordAddress = BlockAddress;\r
\r
- // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
- OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ if (!EfiAtRuntime ()) {\r
+ // Raise TPL to TPL_HIGH to stop anyone from interrupting us.\r
+ OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+ } else {\r
+ // This initialization is only to prevent the compiler to complain about the\r
+ // use of uninitialized variables\r
+ OriginalTPL = TPL_HIGH_LEVEL;\r
+ }\r
\r
Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);\r
- if (EFI_ERROR(Status)) {\r
- DEBUG((EFI_D_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));\r
goto EXIT;\r
}\r
\r
\r
// Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero\r
if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {\r
-\r
// First, break the entire block into buffer-sized chunks.\r
- BuffersInBlock = (UINTN)BlockSizeInWords / P30_MAX_BUFFER_SIZE_IN_BYTES;\r
+ BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;\r
\r
// Then feed each buffer chunk to the NOR Flash\r
- for(BufferIndex=0;\r
+ // If a buffer does not contain any data, don't write it.\r
+ for (BufferIndex = 0;\r
BufferIndex < BuffersInBlock;\r
BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS\r
- ) {\r
- Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer);\r
- if (EFI_ERROR(Status)) {\r
- goto EXIT;\r
+ )\r
+ {\r
+ // Check the buffer to see if it contains any data (not set all 1s).\r
+ for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {\r
+ if (~DataBuffer[Cnt] != 0 ) {\r
+ // Some data found, write the buffer.\r
+ Status = NorFlashWriteBuffer (\r
+ Instance,\r
+ WordAddress,\r
+ P30_MAX_BUFFER_SIZE_IN_BYTES,\r
+ DataBuffer\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ goto EXIT;\r
+ }\r
+\r
+ break;\r
+ }\r
}\r
}\r
\r
// Finally, finish off any remaining words that are less than the maximum size of the buffer\r
RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;\r
\r
- if(RemainingWords != 0) {\r
+ if (RemainingWords != 0) {\r
Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);\r
- if (EFI_ERROR(Status)) {\r
+ if (EFI_ERROR (Status)) {\r
goto EXIT;\r
}\r
}\r
-\r
} else {\r
// For now, use the single word programming algorithm\r
// It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,\r
// i.e. which ends in the range 0x......01 - 0x......7F.\r
- for(WordIndex=0; WordIndex<BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {\r
+ for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {\r
Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);\r
- if (EFI_ERROR(Status)) {\r
+ if (EFI_ERROR (Status)) {\r
goto EXIT;\r
}\r
}\r
}\r
\r
EXIT:\r
- // Interruptions can resume.\r
- gBS->RestoreTPL (OriginalTPL);\r
+ if (!EfiAtRuntime ()) {\r
+ // Interruptions can resume.\r
+ gBS->RestoreTPL (OriginalTPL);\r
+ }\r
\r
- if (EFI_ERROR(Status)) {\r
- DEBUG((EFI_D_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));\r
}\r
+\r
return Status;\r
}\r
\r
-\r
EFI_STATUS\r
-NorFlashWriteBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- IN VOID *Buffer\r
+EFIAPI\r
+NorFlashInitialise (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
- UINT32 *pWriteBuffer;\r
- EFI_STATUS Status = EFI_SUCCESS;\r
- EFI_LBA CurrentBlock;\r
- UINT32 BlockSizeInWords;\r
- UINT32 NumBlocks;\r
- UINT32 BlockCount;\r
-\r
- // The buffer must be valid\r
- if (Buffer == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if(Instance->Media.ReadOnly == TRUE) {\r
- return EFI_WRITE_PROTECTED;\r
- }\r
+ EFI_STATUS Status;\r
+ UINT32 Index;\r
+ NOR_FLASH_DESCRIPTION *NorFlashDevices;\r
+ BOOLEAN ContainVariableStorage;\r
\r
- // We must have some bytes to read\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));\r
- if(BufferSizeInBytes == 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // The size of the buffer must be a multiple of the block size\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));\r
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
+ Status = NorFlashPlatformInitialization ();\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));\r
+ return Status;\r
}\r
\r
- // All blocks must be within the device\r
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;\r
-\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));\r
-\r
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
- DEBUG((EFI_D_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));\r
- return EFI_INVALID_PARAMETER;\r
+ Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n"));\r
+ return Status;\r
}\r
\r
- BlockSizeInWords = Instance->Media.BlockSize / 4;\r
-\r
- // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer\r
- // to a proper data type, so use *ReadBuffer\r
- pWriteBuffer = (UINT32 *)Buffer;\r
+ mNorFlashInstances = AllocateRuntimePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount);\r
\r
- CurrentBlock = Lba;\r
- for (BlockCount=0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {\r
-\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));\r
+ for (Index = 0; Index < mNorFlashDeviceCount; Index++) {\r
+ // Check if this NOR Flash device contain the variable storage region\r
\r
- Status = NorFlashWriteSingleBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);\r
+ if (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) {\r
+ ContainVariableStorage =\r
+ (NorFlashDevices[Index].RegionBaseAddress <= PcdGet64 (PcdFlashNvStorageVariableBase64)) &&\r
+ (PcdGet64 (PcdFlashNvStorageVariableBase64) + PcdGet32 (PcdFlashNvStorageVariableSize) <=\r
+ NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
+ } else {\r
+ ContainVariableStorage =\r
+ (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&\r
+ (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <=\r
+ NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
+ }\r
\r
- if (EFI_ERROR(Status)) {\r
- break;\r
+ Status = NorFlashCreateInstance (\r
+ NorFlashDevices[Index].DeviceBaseAddress,\r
+ NorFlashDevices[Index].RegionBaseAddress,\r
+ NorFlashDevices[Index].Size,\r
+ Index,\r
+ NorFlashDevices[Index].BlockSize,\r
+ ContainVariableStorage,\r
+ &mNorFlashInstances[Index]\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index));\r
}\r
}\r
\r
- DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));\r
+ //\r
+ // Register for the virtual address change event\r
+ //\r
+ Status = gBS->CreateEventEx (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_NOTIFY,\r
+ NorFlashVirtualNotifyEvent,\r
+ NULL,\r
+ &gEfiEventVirtualAddressChangeGuid,\r
+ &mNorFlashVirtualAddrChangeEvent\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
return Status;\r
}\r
\r
EFI_STATUS\r
-NorFlashReadBlocks (\r
- IN NOR_FLASH_INSTANCE *Instance,\r
- IN EFI_LBA Lba,\r
- IN UINTN BufferSizeInBytes,\r
- OUT VOID *Buffer\r
+EFIAPI\r
+NorFlashFvbInitialize (\r
+ IN NOR_FLASH_INSTANCE *Instance\r
)\r
{\r
- UINT32 NumBlocks;\r
- UINTN StartAddress;\r
-\r
- // The buffer must be valid\r
- if (Buffer == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // We must have some bytes to read\r
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%x bytes.\n", BufferSizeInBytes));\r
- if(BufferSizeInBytes == 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // The size of the buffer must be a multiple of the block size\r
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BlockSize=0x%x bytes.\n", Instance->Media.BlockSize));\r
- if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {\r
- return EFI_BAD_BUFFER_SIZE;\r
- }\r
-\r
- // All blocks must be within the device\r
- NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;\r
-\r
- DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld\n", NumBlocks, Instance->Media.LastBlock, Lba));\r
-\r
- if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {\r
- DEBUG((EFI_D_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- // Get the address to start reading from\r
- StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,\r
- Lba,\r
- Instance->Media.BlockSize\r
- );\r
-\r
- // Put the device into Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
-\r
- // Readout the data\r
- CopyMem(Buffer, (UINTN *)StartAddress, BufferSizeInBytes);\r
+ EFI_STATUS Status;\r
+ UINT32 FvbNumLba;\r
+ EFI_BOOT_MODE BootMode;\r
+ UINTN RuntimeMmioRegionSize;\r
+\r
+ DEBUG ((DEBUG_BLKIO, "NorFlashFvbInitialize\n"));\r
+ ASSERT ((Instance != NULL));\r
+\r
+ //\r
+ // Declare the Non-Volatile storage as EFI_MEMORY_RUNTIME\r
+ //\r
+\r
+ // Note: all the NOR Flash region needs to be reserved into the UEFI Runtime memory;\r
+ // even if we only use the small block region at the top of the NOR Flash.\r
+ // The reason is when the NOR Flash memory is set into program mode, the command\r
+ // is written as the base of the flash region (ie: Instance->DeviceBaseAddress)\r
+ RuntimeMmioRegionSize = (Instance->RegionBaseAddress - Instance->DeviceBaseAddress) + Instance->Size;\r
+\r
+ Status = gDS->AddMemorySpace (\r
+ EfiGcdMemoryTypeMemoryMappedIo,\r
+ Instance->DeviceBaseAddress,\r
+ RuntimeMmioRegionSize,\r
+ EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
\r
- return EFI_SUCCESS;\r
-}\r
+ Status = gDS->SetMemorySpaceAttributes (\r
+ Instance->DeviceBaseAddress,\r
+ RuntimeMmioRegionSize,\r
+ EFI_MEMORY_UC | EFI_MEMORY_RUNTIME\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
\r
-EFI_STATUS\r
-NorFlashReset (\r
- IN NOR_FLASH_INSTANCE *Instance\r
- )\r
-{\r
- // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode\r
- SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);\r
- return EFI_SUCCESS;\r
-}\r
+ mFlashNvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?\r
+ PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);\r
\r
-EFI_STATUS\r
-EFIAPI\r
-NorFlashInitialise (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
- )\r
-{\r
- EFI_STATUS Status;\r
- UINT32 Index;\r
- NOR_FLASH_DESCRIPTION* NorFlashDevices;\r
- UINT32 NorFlashDeviceCount;\r
- BOOLEAN ContainVariableStorage;\r
+ // Set the index of the first LBA for the FVB\r
+ Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize;\r
\r
- Status = NorFlashPlatformInitialization ();\r
- if (EFI_ERROR(Status)) {\r
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));\r
- return Status;\r
+ BootMode = GetBootModeHob ();\r
+ if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {\r
+ Status = EFI_INVALID_PARAMETER;\r
+ } else {\r
+ // Determine if there is a valid header at the beginning of the NorFlash\r
+ Status = ValidateFvHeader (Instance);\r
}\r
\r
- Status = NorFlashPlatformGetDevices (&NorFlashDevices,&NorFlashDeviceCount);\r
- if (EFI_ERROR(Status)) {\r
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));\r
- return Status;\r
- }\r
+ // Install the Default FVB header if required\r
+ if (EFI_ERROR (Status)) {\r
+ // There is no valid header, so time to install one.\r
+ DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "%a: Installing a correct one for this volume.\n",\r
+ __FUNCTION__\r
+ ));\r
\r
- mNorFlashInstances = AllocatePool (sizeof(NOR_FLASH_INSTANCE*) * NorFlashDeviceCount);\r
+ // Erase all the NorFlash that is reserved for variable storage\r
+ FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;\r
\r
- for (Index = 0; Index < NorFlashDeviceCount; Index++) {\r
- // Check if this NOR Flash device contain the variable storage region\r
- ContainVariableStorage =\r
- (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&\r
- (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);\r
+ Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
\r
- Status = NorFlashCreateInstance (\r
- NorFlashDevices[Index].DeviceBaseAddress,\r
- NorFlashDevices[Index].RegionBaseAddress,\r
- NorFlashDevices[Index].Size,\r
- Index,\r
- NorFlashDevices[Index].BlockSize,\r
- ContainVariableStorage,\r
- &NorFlashDevices[Index].Guid,\r
- &mNorFlashInstances[Index]\r
- );\r
- if (EFI_ERROR(Status)) {\r
- DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));\r
+ // Install all appropriate headers\r
+ Status = InitializeFvAndVariableStoreHeaders (Instance);\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
}\r
}\r
\r
+ //\r
+ // The driver implementing the variable read service can now be dispatched;\r
+ // the varstore headers are in place.\r
+ //\r
+ Status = gBS->InstallProtocolInterface (\r
+ &gImageHandle,\r
+ &gEdkiiNvVarStoreFormattedGuid,\r
+ EFI_NATIVE_INTERFACE,\r
+ NULL\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ //\r
+ // Register for the virtual address change event\r
+ //\r
+ Status = gBS->CreateEventEx (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_NOTIFY,\r
+ FvbVirtualNotifyEvent,\r
+ NULL,\r
+ &gEfiEventVirtualAddressChangeGuid,\r
+ &mFvbVirtualAddrChangeEvent\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
return Status;\r
}\r