* [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver
@ 2019-04-02 13:10 Jagadeesh Ujja
[not found] ` <CADpYukZHE6NY-U=EycJBVGbQ-XcxXpeT9w6svzWMePjvQXFciQ@mail.gmail.com>
0 siblings, 1 reply; 10+ messages in thread
From: Jagadeesh Ujja @ 2019-04-02 13:10 UTC (permalink / raw)
To: edk2-devel, leif.lindholm, ard.biesheuvel
Refactor the existing ArmPlatformPkg NOR flash driver to be usable
as a StandaloneMM library. Some of the functionality not required
in StandaloneMM, such as the block layer, is removed. This allows
storing of EFI variables on NOR flash which is accessible only via
the MM STANDALONE mode software
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Jagadeesh Ujja <jagadeesh.ujja@arm.com>
---
Changes since v1:
- This is a next version of patch
“[edk2] [PATCH 0/2] Allow use of ArmPlatformPkg NOR flash driver in StandaloneMM”
https://lists.01.org/pipermail/edk2-devel/2019-February/036882.html
https://lists.01.org/pipermail/edk2-devel/2019-February/036884.html
https://lists.01.org/pipermail/edk2-devel/2019-February/036883.html
- ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and disk
I/O protocols. This driver is required in StandaloneMM but the block I/O
and disk I/O protocols are not required in StandaloneMM.
- Instead of removing support for block I/O and disk I/O protocols,
add a new refactored nor flash driver in "Platform/ARM/Drivers"
- Addressed all the comments from Ard Biesheuvel.
Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c | 982 ++++++++++++++++++++
Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h | 326 +++++++
Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c | 740 +++++++++++++++
Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c | 250 +++++
Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf | 68 ++
5 files changed, 2366 insertions(+)
diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c
new file mode 100644
index 0000000..4ba4fb5
--- /dev/null
+++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c
@@ -0,0 +1,982 @@
+/** @file NorFlash.c
+
+ Copyright (c) 2019, ARM Ltd. All rights reserved.
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the
+ BSD License which accompanies this distribution. The full text of the
+ license may be found at http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+#include <Library/UefiLib.h>
+
+#include "NorFlash.h"
+
+STATIC
+UINT32
+NorFlashReadStatusRegister (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN SR_Address
+ )
+{
+ // Prepare to read the status register
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);
+ return MmioRead32 (Instance->DeviceBaseAddress);
+}
+
+STATIC
+BOOLEAN
+NorFlashBlockIsLocked (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ )
+{
+ UINT32 LockStatus;
+
+ // Send command for reading device id
+ SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
+
+ // Read block lock status
+ LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));
+
+ // Decode block lock status
+ LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);
+
+ if ((LockStatus & 0x2) != 0) {
+ DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));
+ }
+
+ return ((LockStatus & 0x1) != 0);
+}
+
+STATIC
+EFI_STATUS
+NorFlashUnlockSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ )
+{
+ UINT32 LockStatus;
+
+ // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations
+ // and to protect shared data structures.
+
+ if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {
+ do {
+ // Request a lock setup
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
+
+ // Request an unlock
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
+
+ // Send command for reading device id
+ SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
+
+ // Read block lock status
+ LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));
+
+ // Decode block lock status
+ LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);
+ } while ((LockStatus & 0x1) == 1);
+ } else {
+ // Request a lock setup
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
+
+ // Request an unlock
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
+
+ // Wait until the status register gives us the all clear
+ do {
+ LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);
+ } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
+ }
+
+ // Put device back into Read Array mode
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);
+
+ DEBUG ((DEBUG_BLKIO,
+ "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress));
+
+ return EFI_SUCCESS;
+}
+
+STATIC
+EFI_STATUS
+NorFlashUnlockSingleBlockIfNecessary (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ )
+{
+ EFI_STATUS Status;
+
+ Status = EFI_SUCCESS;
+
+ if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {
+ Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);
+ }
+
+ return Status;
+}
+
+/**
+ * The following function presumes that the block has already been unlocked.
+ **/
+STATIC
+EFI_STATUS
+NorFlashEraseSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ )
+{
+ EFI_STATUS Status;
+ UINT32 StatusRegister;
+
+ Status = EFI_SUCCESS;
+
+ // Request a block erase and then confirm it
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);
+ SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);
+
+ // Wait until the status register gives us the all clear
+ do {
+ StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);
+ } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
+
+ if (StatusRegister & P30_SR_BIT_VPP) {
+ DEBUG ((DEBUG_ERROR,
+ "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) ==
+ (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {
+ DEBUG ((DEBUG_ERROR,
+ "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n",
+ BlockAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_ERASE) {
+ DEBUG ((DEBUG_ERROR,
+ "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n",
+ BlockAddress, StatusRegister));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
+ // The debug level message has been reduced because a device
+ // lock might happen. In this case we just retry it ...
+ DEBUG ((DEBUG_INFO,
+ "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n",
+ BlockAddress));
+ Status = EFI_WRITE_PROTECTED;
+ }
+
+ if (EFI_ERROR (Status)) {
+ // Clear the Status Register
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
+ }
+
+ // Put device back into Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+
+ return Status;
+}
+
+/**
+ * This function unlock and erase an entire NOR Flash block.
+ **/
+EFI_STATUS
+NorFlashUnlockAndEraseSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ )
+{
+ EFI_STATUS Status;
+ UINTN Index;
+ NOR_FLASH_LOCK_CONTEXT Lock;
+
+ NorFlashLock (&Lock);
+
+ Index = 0;
+ // The block erase might fail a first time (SW bug ?). Retry it ...
+ do {
+ // Unlock the block if we have to
+ Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
+ if (EFI_ERROR (Status)) {
+ break;
+ }
+ Status = NorFlashEraseSingleBlock (Instance, BlockAddress);
+ Index++;
+ } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));
+
+ if (Index == NOR_FLASH_ERASE_RETRY) {
+ DEBUG ((DEBUG_ERROR,
+ "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n",
+ BlockAddress,Index));
+ }
+
+ NorFlashUnlock (&Lock);
+
+ return Status;
+}
+
+STATIC
+EFI_STATUS
+NorFlashWriteSingleWord (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN WordAddress,
+ IN UINT32 WriteData
+ )
+{
+ EFI_STATUS Status;
+ UINT32 StatusRegister;
+
+ Status = EFI_SUCCESS;
+
+ // Request a write single word command
+ SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);
+
+ // Store the word into NOR Flash;
+ MmioWrite32 (WordAddress, WriteData);
+
+ // Wait for the write to complete and then check for any errors;
+ // i.e. check the Status Register
+ do {
+ // Prepare to read the status register
+ StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);
+ // The chip is busy while the WRITE bit is not asserted
+ } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
+
+
+ // Perform a full status check:
+ // Mask the relevant bits of Status Register.
+ // Everything should be zero, if not, we have a problem
+
+ if (StatusRegister & P30_SR_BIT_VPP) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",
+ WordAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_PROGRAM) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",
+ WordAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",
+ WordAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (!EFI_ERROR (Status)) {
+ // Clear the Status Register
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress,
+ 0, P30_CMD_CLEAR_STATUS_REGISTER);
+ }
+
+ // Put device back into Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+
+ return Status;
+}
+
+/*
+ * Writes data to the NOR Flash using the Buffered Programming method.
+ *
+ * The maximum size of the on-chip buffer is 32-words, because of hardware
+ * restrictions. Therefore this function will only handle buffers up to 32
+ * words or 128 bytes. To deal with larger buffers, call this function again.
+ *
+ * This function presumes that both the TargetAddress and the
+ * TargetAddress+BufferSize exist entirely within the NOR Flash.
+ * Therefore these conditions will not be checked here.
+ *
+ * In buffered programming, if the target address not at the beginning of a
+ * 32-bit word boundary,then programming time is doubled and power consumption
+ * is increased. Therefore, it is a requirement to align buffer writes to
+ * 32-bit word boundaries.
+ * i.e. the last 4 bits of the target start address must be zero: 0x......00
+ */
+EFI_STATUS
+NorFlashWriteBuffer (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN TargetAddress,
+ IN UINTN BufferSizeInBytes,
+ IN UINT32 *Buffer
+ )
+{
+ EFI_STATUS Status;
+ UINTN BufferSizeInWords;
+ UINTN Count;
+ volatile UINT32 *Data;
+ UINTN WaitForBuffer;
+ BOOLEAN BufferAvailable;
+ UINT32 StatusRegister;
+
+ WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS;
+ BufferAvailable = FALSE;
+
+ // Check that the target address does not cross a 32-word boundary.
+ if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Check there are some data to program
+ if (BufferSizeInBytes == 0) {
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ // Check that the buffer size does not exceed the maximum hardware buffer
+ // size on chip.
+ if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // Check that the buffer size is a multiple of 32-bit words
+ if ((BufferSizeInBytes % 4) != 0) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // Pre-programming conditions checked, now start the algorithm.
+
+ // Prepare the data destination address
+ Data = (UINT32 *)TargetAddress;
+
+ // Check the availability of the buffer
+ do {
+ // Issue the Buffered Program Setup command
+ SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);
+
+ // Read back the status register bit#7 from the same address
+ if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {
+ BufferAvailable = TRUE;
+ }
+
+ // Update the loop counter
+ WaitForBuffer--;
+
+ } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));
+
+ // The buffer was not available for writing
+ if (WaitForBuffer == 0) {
+ Status = EFI_DEVICE_ERROR;
+ goto EXIT;
+ }
+
+ // From now on we work in 32-bit words
+ BufferSizeInWords = BufferSizeInBytes / (UINTN)4;
+
+ // Write the word count, which is (buffer_size_in_words - 1),
+ // because word count 0 means one word.
+ SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1));
+
+ // Write the data to the NOR Flash, advancing each address by 4 bytes
+ for (Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {
+ MmioWrite32 ((UINTN)Data, *Buffer);
+ }
+
+ // Issue the Buffered Program Confirm command, to start the programming operation
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);
+
+ // Wait for the write to complete and then check for any errors;
+ // i.e. check the Status Register
+ do {
+ StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);
+ // The chip is busy while the WRITE bit is not asserted
+ } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
+
+
+ // Perform a full status check:
+ // Mask the relevant bits of Status Register.
+ // Everything should be zero, if not, we have a problem
+
+ Status = EFI_SUCCESS;
+
+ if (StatusRegister & P30_SR_BIT_VPP) {
+ DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): VPP Range Error\n",
+ TargetAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_PROGRAM) {
+ DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Program Error\n",
+ TargetAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
+ DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Device Protect Error\n",
+ TargetAddress));
+ Status = EFI_DEVICE_ERROR;
+ }
+
+ if (!EFI_ERROR (Status)) {
+ // Clear the Status Register
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
+ }
+
+EXIT:
+ // Put device back into Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+
+ return Status;
+}
+
+STATIC
+EFI_STATUS
+NorFlashWriteFullBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINT32 *DataBuffer,
+ IN UINT32 BlockSizeInWords
+ )
+{
+ EFI_STATUS Status;
+ UINTN WordAddress;
+ UINT32 WordIndex;
+ UINTN BufferIndex;
+ UINTN BlockAddress;
+ UINTN BuffersInBlock;
+ UINTN RemainingWords;
+ UINTN Cnt;
+ NOR_FLASH_LOCK_CONTEXT Lock;
+
+ Status = EFI_SUCCESS;
+
+ // Get the physical address of the block
+ BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);
+
+ // Start writing from the first address at the start of the block
+ WordAddress = BlockAddress;
+
+ NorFlashLock (&Lock);
+
+ Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR,
+ "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n",
+ BlockAddress));
+ goto EXIT;
+ }
+
+ // To speed up the programming operation, NOR Flash is programmed using the
+ // Buffered Programming method.
+
+ // Check that the address starts at a 32-word boundary,
+ // i.e. last 7 bits must be zero
+ if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {
+
+ // First, break the entire block into buffer-sized chunks.
+ BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;
+
+ // Then feed each buffer chunk to the NOR Flash
+ // If a buffer does not contain any data, don't write it.
+ for (BufferIndex=0;
+ BufferIndex < BuffersInBlock;
+ BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES,
+ DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS
+ ) {
+ // Check the buffer to see if it contains any data (not set all 1s).
+ for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {
+ if (~DataBuffer[Cnt] != 0 ) {
+ // Some data found, write the buffer.
+ Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES,
+ DataBuffer);
+ if (EFI_ERROR (Status)) {
+ goto EXIT;
+ }
+ break;
+ }
+ }
+ }
+
+ // Finally, finish off any remaining words that are less than the
+ // maximum size of the buffer
+ RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;
+
+ if (RemainingWords != 0) {
+ Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);
+ if (EFI_ERROR (Status)) {
+ goto EXIT;
+ }
+ }
+
+ } else {
+ // For now, use the single word programming algorithm
+ // It is unlikely that the NOR Flash will exist in an address which falls
+ // within a 32 word boundary range,
+ // i.e. which ends in the range 0x......01 - 0x......7F.
+ for (WordIndex=0;
+ WordIndex<BlockSizeInWords;
+ WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {
+ Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
+ if (EFI_ERROR (Status)) {
+ goto EXIT;
+ }
+ }
+ }
+
+EXIT:
+ NorFlashUnlock (&Lock);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR,
+ "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n",
+ WordAddress, Status));
+ }
+ return Status;
+}
+
+EFI_STATUS
+NorFlashWriteBlocks (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN BufferSizeInBytes,
+ IN VOID *Buffer
+ )
+{
+ UINT32 *pWriteBuffer;
+ EFI_STATUS Status = EFI_SUCCESS;
+ EFI_LBA CurrentBlock;
+ UINT32 BlockSizeInWords;
+ UINT32 NumBlocks;
+ UINT32 BlockCount;
+
+ // The buffer must be valid
+ if (Buffer == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // We must have some bytes to read
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));
+ if (BufferSizeInBytes == 0) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // The size of the buffer must be a multiple of the block size
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->BlockSize));
+ if ((BufferSizeInBytes % Instance->BlockSize) != 0) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // All blocks must be within the device
+ NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ;
+
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n",
+ NumBlocks, Instance->LastBlock, Lba));
+
+ if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ BlockSizeInWords = Instance->BlockSize / 4;
+
+ // Because the target *Buffer is a pointer to VOID, we must put all the
+ // data into a pointer to a proper data type, so use *ReadBuffer
+ pWriteBuffer = (UINT32 *)Buffer;
+
+ CurrentBlock = Lba;
+ for (BlockCount=0;
+ BlockCount < NumBlocks;
+ BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {
+
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));
+
+ Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);
+
+ if (EFI_ERROR (Status)) {
+ break;
+ }
+ }
+
+ DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));
+ return Status;
+}
+
+#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0)
+
+/**
+ Copy Length bytes from Source to Destination, using aligned accesses only.
+ Note that this implementation uses memcpy() semantics rather then memmove()
+ semantics, i.e., SourceBuffer and DestinationBuffer should not overlap.
+
+ @param DestinationBuffer The target of the copy request.
+ @param SourceBuffer The place to copy from.
+ @param Length The number of bytes to copy.
+
+ @return Destination
+
+**/
+STATIC
+VOID *
+AlignedCopyMem (
+ OUT VOID *DestinationBuffer,
+ IN CONST VOID *SourceBuffer,
+ IN UINTN Length
+ )
+{
+ UINT8 *Destination8;
+ CONST UINT8 *Source8;
+ UINT32 *Destination32;
+ CONST UINT32 *Source32;
+ UINT64 *Destination64;
+ CONST UINT64 *Source64;
+
+ if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && Length >= 8) {
+ Destination64 = DestinationBuffer;
+ Source64 = SourceBuffer;
+ while (Length >= 8) {
+ *Destination64++ = *Source64++;
+ Length -= 8;
+ }
+
+ Destination8 = (UINT8 *)Destination64;
+ Source8 = (CONST UINT8 *)Source64;
+ } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && Length >= 4) {
+ Destination32 = DestinationBuffer;
+ Source32 = SourceBuffer;
+ while (Length >= 4) {
+ *Destination32++ = *Source32++;
+ Length -= 4;
+ }
+
+ Destination8 = (UINT8 *)Destination32;
+ Source8 = (CONST UINT8 *)Source32;
+ } else {
+ Destination8 = DestinationBuffer;
+ Source8 = SourceBuffer;
+ }
+ while (Length-- != 0) {
+ *Destination8++ = *Source8++;
+ }
+ return DestinationBuffer;
+}
+
+EFI_STATUS
+NorFlashReadBlocks (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN BufferSizeInBytes,
+ OUT VOID *Buffer
+ )
+{
+ UINT32 NumBlocks;
+ UINTN StartAddress;
+
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",
+ BufferSizeInBytes, Instance->BlockSize, Instance->LastBlock, Lba));
+
+ // The buffer must be valid
+ if (Buffer == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Return if we have not any byte to read
+ if (BufferSizeInBytes == 0) {
+ return EFI_SUCCESS;
+ }
+
+ // The size of the buffer must be a multiple of the block size
+ if ((BufferSizeInBytes % Instance->BlockSize) != 0) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // All blocks must be within the device
+ NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ;
+
+ if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Get the address to start reading from
+ StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,
+ Lba,
+ Instance->BlockSize
+ );
+
+ // Put the device into Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+
+ // Readout the data
+ AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes);
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NorFlashRead (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN UINTN BufferSizeInBytes,
+ OUT VOID *Buffer
+ )
+{
+ UINTN StartAddress;
+
+ // The buffer must be valid
+ if (Buffer == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Return if we have not any byte to read
+ if (BufferSizeInBytes == 0) {
+ return EFI_SUCCESS;
+ }
+
+ if (((Lba * Instance->BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) {
+ DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n"));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Get the address to start reading from
+ StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,
+ Lba,
+ Instance->BlockSize
+ );
+
+ // Put the device into Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+
+ // Readout the data
+ AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes);
+
+ return EFI_SUCCESS;
+}
+
+/*
+ Write a full or portion of a block. It must not span block boundaries;
+ that is, Offset + *NumBytes <= Instance->Media.BlockSize.
+*/
+EFI_STATUS
+NorFlashWriteSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN UINT8 *Buffer
+ )
+{
+ EFI_STATUS TempStatus;
+ UINT32 Tmp;
+ UINT32 TmpBuf;
+ UINT32 WordToWrite;
+ UINT32 Mask;
+ BOOLEAN DoErase;
+ UINTN BytesToWrite;
+ UINTN CurOffset;
+ UINTN WordAddr;
+ UINTN BlockSize;
+ UINTN BlockAddress;
+ UINTN PrevBlockAddress;
+
+ PrevBlockAddress = 0;
+
+ DEBUG ((DEBUG_BLKIO,
+ "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n",
+ Lba, Offset, *NumBytes, Buffer));
+
+ // Cache the block size to avoid de-referencing pointers all the time
+ BlockSize = Instance->BlockSize;
+
+ // The write must not span block boundaries.
+ // We need to check each variable individually because adding two
+ // large values together overflows.
+ if ( ( Offset >= BlockSize ) ||
+ ( *NumBytes > BlockSize ) ||
+ ( (Offset + *NumBytes) > BlockSize ) ) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \
+ (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n",
+ Offset, *NumBytes, BlockSize ));
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // We must have some bytes to write
+ if (*NumBytes == 0) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \
+ (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n",
+ Offset, *NumBytes, BlockSize ));
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // Pick 128bytes as a good start for word operations as opposed to erasing the
+ // block and writing the data regardless if an erase is really needed.
+ // It looks like most individual NV variable writes are smaller than 128bytes.
+ if (*NumBytes <= 128) {
+ // Check to see if we need to erase before programming the data into NOR.
+ // If the destination bits are only changing from 1s to 0s we can just write.
+ // After a block is erased all bits in the block is set to 1.
+ // If any byte requires us to erase we just give up and rewrite all of it.
+ DoErase = FALSE;
+ BytesToWrite = *NumBytes;
+ CurOffset = Offset;
+
+ while (BytesToWrite > 0) {
+ // Read full word from NOR, splice as required. A word is the smallest
+ // unit we can write.
+ TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp);
+ if (EFI_ERROR (TempStatus)) {
+ return EFI_DEVICE_ERROR;
+ }
+
+ // Physical address of word in NOR to write.
+ WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,
+ Lba, BlockSize);
+ // The word of data that is to be written.
+ TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite)));
+
+ // First do word aligned chunks.
+ if ((CurOffset & 0x3) == 0) {
+ if (BytesToWrite >= 4) {
+ // Is the destination still in 'erased' state?
+ if (~Tmp != 0) {
+ // Check to see if we are only changing bits to zero.
+ if ((Tmp ^ TmpBuf) & TmpBuf) {
+ DoErase = TRUE;
+ break;
+ }
+ }
+ // Write this word to NOR
+ WordToWrite = TmpBuf;
+ CurOffset += sizeof (TmpBuf);
+ BytesToWrite -= sizeof (TmpBuf);
+ } else {
+ // BytesToWrite < 4. Do small writes and left-overs
+ Mask = ~((~0) << (BytesToWrite * 8));
+ // Mask out the bytes we want.
+ TmpBuf &= Mask;
+ // Is the destination still in 'erased' state?
+ if ((Tmp & Mask) != Mask) {
+ // Check to see if we are only changing bits to zero.
+ if ((Tmp ^ TmpBuf) & TmpBuf) {
+ DoErase = TRUE;
+ break;
+ }
+ }
+ // Merge old and new data. Write merged word to NOR
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;
+ CurOffset += BytesToWrite;
+ BytesToWrite = 0;
+ }
+ } else {
+ // Do multiple words, but starting unaligned.
+ if (BytesToWrite > (4 - (CurOffset & 0x3))) {
+ Mask = ((~0) << ((CurOffset & 0x3) * 8));
+ // Mask out the bytes we want.
+ TmpBuf &= Mask;
+ // Is the destination still in 'erased' state?
+ if ((Tmp & Mask) != Mask) {
+ // Check to see if we are only changing bits to zero.
+ if ((Tmp ^ TmpBuf) & TmpBuf) {
+ DoErase = TRUE;
+ break;
+ }
+ }
+ // Merge old and new data. Write merged word to NOR
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;
+ BytesToWrite -= (4 - (CurOffset & 0x3));
+ CurOffset += (4 - (CurOffset & 0x3));
+ } else {
+ // Unaligned and fits in one word.
+ Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8);
+ // Mask out the bytes we want.
+ TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask;
+ // Is the destination still in 'erased' state?
+ if ((Tmp & Mask) != Mask) {
+ // Check to see if we are only changing bits to zero.
+ if ((Tmp ^ TmpBuf) & TmpBuf) {
+ DoErase = TRUE;
+ break;
+ }
+ }
+ // Merge old and new data. Write merged word to NOR
+ WordToWrite = (Tmp & ~Mask) | TmpBuf;
+ CurOffset += BytesToWrite;
+ BytesToWrite = 0;
+ }
+ }
+
+ //
+ // Write the word to NOR.
+ //
+
+ BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize);
+ if (BlockAddress != PrevBlockAddress) {
+ TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
+ if (EFI_ERROR (TempStatus)) {
+ return EFI_DEVICE_ERROR;
+ }
+ PrevBlockAddress = BlockAddress;
+ }
+ TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);
+ if (EFI_ERROR (TempStatus)) {
+ return EFI_DEVICE_ERROR;
+ }
+ }
+ // Exit if we got here and could write all the data. Otherwise do the
+ // Erase-Write cycle.
+ if (!DoErase) {
+ return EFI_SUCCESS;
+ }
+ }
+
+ // Check we did get some memory. Buffer is BlockSize.
+ if (Instance->ShadowBuffer == NULL) {
+ DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));
+ return EFI_DEVICE_ERROR;
+ }
+
+ // Read NOR Flash data into shadow buffer
+ TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);
+ if (EFI_ERROR (TempStatus)) {
+ // Return one of the pre-approved error statuses
+ return EFI_DEVICE_ERROR;
+ }
+
+ // Put the data at the appropriate location inside the buffer area
+ CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);
+
+ // Write the modified buffer back to the NorFlash
+ TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);
+ if (EFI_ERROR (TempStatus)) {
+ // Return one of the pre-approved error statuses
+ return EFI_DEVICE_ERROR;
+ }
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NorFlashReset (
+ IN NOR_FLASH_INSTANCE *Instance
+ )
+{
+ // As there is no specific RESET to perform, ensure that the devices
+ // is in the default Read Array mode
+ SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
+ return EFI_SUCCESS;
+}
diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h
new file mode 100644
index 0000000..0396f7a
--- /dev/null
+++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h
@@ -0,0 +1,326 @@
+/** @file NorFlash.h
+
+ Copyright (c) 2019, ARM Ltd. All rights reserved.
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD
+ License which accompanies this distribution. The full text of the license
+ may be found at http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __NOR_FLASH_H__
+#define __NOR_FLASH_H__
+
+#include <Base.h>
+#include <Guid/EventGroup.h>
+#include <Library/DebugLib.h>
+#include <Library/IoLib.h>
+#include <Library/MmServicesTableLib.h>
+#include <Library/NorFlashPlatformLib.h>
+#include <Library/UefiLib.h>
+#include <Library/UefiRuntimeLib.h>
+#include <Protocol/FirmwareVolumeBlock.h>
+
+#define NOR_FLASH_ERASE_RETRY 10
+
+// Device access macros
+// These are necessary because we use 2 x 16bit parts to make up 32bit data
+
+#define HIGH_16_BITS 0xFFFF0000
+#define LOW_16_BITS 0x0000FFFF
+#define LOW_8_BITS 0x000000FF
+
+#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | \
+ ( value & LOW_16_BITS ) )
+
+#define GET_LOW_BYTE(value) ( value & LOW_8_BITS )
+#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE ( value >> 16 ) )
+
+// Each command must be sent simultaneously to both chips,
+// i.e. at the lower 16 bits AND at the higher 16 bits
+#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr) ( ( BaseAddr ) + \
+ ( ( OffsetAddr ) << 2))
+#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16 ) | \
+ ( Cmd & LOW_16_BITS ) )
+#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 \
+ ( CREATE_NOR_ADDRESS ( BaseAddr,Offset ), \
+ CREATE_DUAL_CMD ( Cmd) )
+#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + \
+ ( UINTN )( ( Lba ) * LbaSize ) )
+
+// Status Register Bits
+#define P30_SR_BIT_WRITE ( BIT7 << 16 | BIT7 )
+#define P30_SR_BIT_ERASE_SUSPEND ( BIT6 << 16 | BIT6 )
+#define P30_SR_BIT_ERASE ( BIT5 << 16 | BIT5 )
+#define P30_SR_BIT_PROGRAM ( BIT4 << 16 | BIT4 )
+#define P30_SR_BIT_VPP ( BIT3 << 16 | BIT3 )
+#define P30_SR_BIT_PROGRAM_SUSPEND ( BIT2 << 16 | BIT2 )
+#define P30_SR_BIT_BLOCK_LOCKED ( BIT1 << 16 | BIT1 )
+#define P30_SR_BIT_BEFP ( BIT0 << 16 | BIT0 )
+
+// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family
+
+// On chip buffer size for buffered programming operations
+// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each
+// word is 2 bytes.
+// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes
+#define P30_MAX_BUFFER_SIZE_IN_BYTES ( ( UINTN ) 128 )
+#define P30_MAX_BUFFER_SIZE_IN_WORDS ( P30_MAX_BUFFER_SIZE_IN_BYTES/ ( ( UINTN) 4 ) )
+#define MAX_BUFFERED_PROG_ITERATIONS 10000000
+#define BOUNDARY_OF_32_WORDS 0x7F
+
+// CFI Addresses
+#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10
+#define P30_CFI_ADDR_VENDOR_ID 0x13
+
+// CFI Data
+#define CFI_QRY 0x00595251
+
+// READ Commands
+#define P30_CMD_READ_DEVICE_ID 0x0090
+#define P30_CMD_READ_STATUS_REGISTER 0x0070
+#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050
+#define P30_CMD_READ_ARRAY 0x00FF
+#define P30_CMD_READ_CFI_QUERY 0x0098
+
+// WRITE Commands
+#define P30_CMD_WORD_PROGRAM_SETUP 0x0040
+#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010
+#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8
+#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0
+#define P30_CMD_BEFP_SETUP 0x0080
+#define P30_CMD_BEFP_CONFIRM 0x00D0
+
+// ERASE Commands
+#define P30_CMD_BLOCK_ERASE_SETUP 0x0020
+#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0
+
+// SUSPEND Commands
+#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0
+#define P30_CMD_SUSPEND_RESUME 0x00D0
+
+// BLOCK LOCKING / UNLOCKING Commands
+#define P30_CMD_LOCK_BLOCK_SETUP 0x0060
+#define P30_CMD_LOCK_BLOCK 0x0001
+#define P30_CMD_UNLOCK_BLOCK 0x00D0
+#define P30_CMD_LOCK_DOWN_BLOCK 0x002F
+
+// PROTECTION Commands
+#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0
+
+// CONFIGURATION Commands
+#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060
+#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003
+
+#define NOR_FLASH_SIGNATURE SIGNATURE_32 ('n', 'o', 'r', '0')
+#define INSTANCE_FROM_FVB_THIS(a) CR (a, NOR_FLASH_INSTANCE, \
+ FvbProtocol, \
+ NOR_FLASH_SIGNATURE)
+#define INSTANCE_FROM_BLKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \
+ BlockIoProtocol, \
+ NOR_FLASH_SIGNATURE)
+#define INSTANCE_FROM_DISKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \
+ DiskIoProtocol, \
+ NOR_FLASH_SIGNATURE)
+
+typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE;
+extern UINTN mFlashNvStorageVariableBase;
+
+#pragma pack (1)
+typedef struct {
+ VENDOR_DEVICE_PATH Vendor;
+ UINT8 Index;
+ EFI_DEVICE_PATH_PROTOCOL End;
+} NOR_FLASH_DEVICE_PATH;
+#pragma pack ()
+
+struct _NOR_FLASH_INSTANCE {
+ UINT32 Signature;
+ EFI_HANDLE Handle;
+
+ UINTN DeviceBaseAddress;
+ UINTN RegionBaseAddress;
+ UINTN Size;
+ UINT32 BlockSize;
+ UINT32 LastBlock;
+ EFI_LBA StartLba;
+
+ EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;
+ VOID* ShadowBuffer;
+
+ NOR_FLASH_DEVICE_PATH DevicePath;
+};
+
+EFI_STATUS
+NorFlashWriteBuffer (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN TargetAddress,
+ IN UINTN BufferSizeInBytes,
+ IN UINT32 *Buffer
+ );
+
+EFI_STATUS
+NorFlashCreateInstance (
+ IN UINTN NorFlashDeviceBase,
+ IN UINTN NorFlashRegionBase,
+ IN UINTN NorFlashSize,
+ IN UINT32 Index,
+ IN UINT32 BlockSize,
+ IN BOOLEAN SupportFvb,
+ OUT NOR_FLASH_INSTANCE** NorFlashInstance
+ );
+
+EFI_STATUS
+EFIAPI
+NorFlashFvbInitialize (
+ IN NOR_FLASH_INSTANCE* Instance
+ );
+
+EFI_STATUS
+ValidateFvHeader (
+ IN NOR_FLASH_INSTANCE *Instance
+ );
+
+EFI_STATUS
+InitializeFvAndVariableStoreHeaders (
+ IN NOR_FLASH_INSTANCE *Instance
+ );
+
+EFI_STATUS
+EFIAPI
+NorFlashFvbInitialize (
+ IN NOR_FLASH_INSTANCE* Instance
+ );
+
+EFI_STATUS
+EFIAPI
+FvbGetAttributes (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ OUT EFI_FVB_ATTRIBUTES_2 *Attributes
+ );
+
+EFI_STATUS
+EFIAPI
+FvbSetAttributes (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
+ );
+
+EFI_STATUS
+EFIAPI
+FvbGetPhysicalAddress (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ OUT EFI_PHYSICAL_ADDRESS *Address
+ );
+
+EFI_STATUS
+EFIAPI
+FvbGetBlockSize (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ OUT UINTN *BlockSize,
+ OUT UINTN *NumberOfBlocks
+ );
+
+EFI_STATUS
+EFIAPI
+FvbRead (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN OUT UINT8 *Buffer
+ );
+
+EFI_STATUS
+EFIAPI
+FvbWrite (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN UINT8 *Buffer
+ );
+
+EFI_STATUS
+EFIAPI
+FvbEraseBlocks (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ ...
+ );
+
+typedef struct {
+ EFI_TPL OriginalTPL;
+} NOR_FLASH_LOCK_CONTEXT;
+
+VOID
+EFIAPI
+NorFlashLock (
+ NOR_FLASH_LOCK_CONTEXT *Context
+ );
+
+VOID
+EFIAPI
+NorFlashUnlock (
+ NOR_FLASH_LOCK_CONTEXT *Context
+ );
+
+EFI_STATUS
+NorFlashUnlockAndEraseSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN UINTN BlockAddress
+ );
+
+EFI_STATUS
+NorFlashWriteSingleBlock (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN UINT8 *Buffer
+ );
+
+EFI_STATUS
+NorFlashWriteBlocks (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN BufferSizeInBytes,
+ IN VOID *Buffer
+ );
+
+EFI_STATUS
+NorFlashReadBlocks (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN BufferSizeInBytes,
+ OUT VOID *Buffer
+ );
+
+EFI_STATUS
+NorFlashRead (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN UINTN BufferSizeInBytes,
+ OUT VOID *Buffer
+ );
+
+EFI_STATUS
+NorFlashWrite (
+ IN NOR_FLASH_INSTANCE *Instance,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN UINT8 *Buffer
+ );
+
+EFI_STATUS
+NorFlashReset (
+ IN NOR_FLASH_INSTANCE *Instance
+ );
+
+#endif /* __NOR_FLASH_H__ */
diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c
new file mode 100644
index 0000000..6ad3769
--- /dev/null
+++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c
@@ -0,0 +1,740 @@
+/*++ @file NorFlashFvb.c
+
+ Copyright (c) 2019, ARM Ltd. All rights reserved.
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the
+ BSD License which accompanies this distribution. The full text of the
+ license may be found at http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ --*/
+
+#include <Guid/VariableFormat.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+#include <Library/UefiLib.h>
+
+#include "NorFlash.h"
+
+UINTN mFlashNvStorageVariableBase;
+
+///
+/// The Firmware Volume Block Protocol is the low-level interface
+/// to a firmware volume. File-level access to a firmware volume
+/// should not be done using the Firmware Volume Block Protocol.
+/// Normal access to a firmware volume must use the Firmware
+/// Volume Protocol. Typically, only the file system driver that
+/// produces the Firmware Volume Protocol will bind to the
+/// Firmware Volume Block Protocol.
+///
+
+/**
+ Initialises the FV Header and Variable Store Header
+ to support variable operations.
+
+ @param[in] Ptr - Location to initialise the headers
+
+**/
+EFI_STATUS
+InitializeFvAndVariableStoreHeaders (
+ IN NOR_FLASH_INSTANCE *Instance
+ )
+{
+ EFI_STATUS Status;
+ VOID* Headers;
+ UINTN HeadersLength;
+ EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader;
+ VARIABLE_STORE_HEADER *VariableStoreHeader;
+
+ HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) +
+ sizeof (EFI_FV_BLOCK_MAP_ENTRY) +
+ sizeof (VARIABLE_STORE_HEADER);
+ Headers = AllocateZeroPool (HeadersLength);
+
+ // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND
+ // the FTW working area AND the FTW Spare contiguous.
+ ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) +
+ PcdGet32 (PcdFlashNvStorageVariableSize) ==
+ PcdGet32 (PcdFlashNvStorageFtwWorkingBase));
+ ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) +
+ PcdGet32 (PcdFlashNvStorageFtwWorkingSize) ==
+ PcdGet32 (PcdFlashNvStorageFtwSpareBase));
+
+ // Check if the size of the area is at least one block size
+ ASSERT ((PcdGet32 (PcdFlashNvStorageVariableSize) > 0) &&
+ (PcdGet32 (PcdFlashNvStorageVariableSize) / Instance->BlockSize > 0));
+ ASSERT ((PcdGet32 (PcdFlashNvStorageFtwWorkingSize) > 0) &&
+ (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) / Instance->BlockSize > 0));
+ ASSERT ((PcdGet32 (PcdFlashNvStorageFtwSpareSize) > 0) &&
+ (PcdGet32 (PcdFlashNvStorageFtwSpareSize) / Instance->BlockSize > 0));
+
+ // Ensure the Variable area Base Addresses are aligned on a
+ // block size boundaries
+ ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) % Instance->BlockSize == 0);
+ ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) % Instance->BlockSize == 0);
+ ASSERT (PcdGet32 (PcdFlashNvStorageFtwSpareBase) % Instance->BlockSize == 0);
+
+ //
+ // EFI_FIRMWARE_VOLUME_HEADER
+ //
+ FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers;
+ CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
+ FirmwareVolumeHeader->FvLength =
+ PcdGet32 (PcdFlashNvStorageVariableSize) +
+ PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
+ PcdGet32 (PcdFlashNvStorageFtwSpareSize);
+ FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;
+ FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) (
+ EFI_FVB2_READ_ENABLED_CAP |
+ // Reads may be enabled
+ EFI_FVB2_READ_STATUS |
+ // Reads are currently enabled
+ EFI_FVB2_STICKY_WRITE |
+ // A block erase is required to flip
+ // bits into EFI_FVB2_ERASE_POLARITY
+ EFI_FVB2_MEMORY_MAPPED |
+ // It is memory mapped
+ EFI_FVB2_ERASE_POLARITY |
+ // After erasure all bits take this
+ // value (i.e. '1')
+ EFI_FVB2_WRITE_STATUS |
+ // Writes are currently enabled
+ EFI_FVB2_WRITE_ENABLED_CAP
+ // Writes may be enabled
+ );
+ FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) +
+ sizeof (EFI_FV_BLOCK_MAP_ENTRY);
+ FirmwareVolumeHeader->Revision = EFI_FVH_REVISION;
+ FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->LastBlock + 1;
+ FirmwareVolumeHeader->BlockMap[0].Length = Instance->BlockSize;
+ FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;
+ FirmwareVolumeHeader->BlockMap[1].Length = 0;
+ FirmwareVolumeHeader->Checksum = CalculateCheckSum16 (
+ (UINT16*)FirmwareVolumeHeader,
+ FirmwareVolumeHeader->HeaderLength);
+
+ //
+ // VARIABLE_STORE_HEADER
+ //
+ VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)Headers +
+ FirmwareVolumeHeader->HeaderLength);
+ CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid);
+ VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) -
+ FirmwareVolumeHeader->HeaderLength;
+ VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED;
+ VariableStoreHeader->State = VARIABLE_STORE_HEALTHY;
+
+ // Install the combined super-header in the NorFlash
+ Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);
+
+ FreePool (Headers);
+ return Status;
+}
+
+/**
+ Check the integrity of firmware volume header.
+
+ @param[in] FwVolHeader - A pointer to a firmware volume header
+
+ @retval EFI_SUCCESS - The firmware volume is consistent
+ @retval EFI_NOT_FOUND - The firmware volume has been corrupted.
+
+**/
+EFI_STATUS
+ValidateFvHeader (
+ IN NOR_FLASH_INSTANCE *Instance
+ )
+{
+ UINT16 Checksum;
+ EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
+ VARIABLE_STORE_HEADER *VariableStoreHeader;
+ UINTN VariableStoreLength;
+ UINTN FvLength;
+
+ FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress;
+
+ FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) +
+ PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
+ PcdGet32 (PcdFlashNvStorageFtwSpareSize);
+
+ //
+ // Verify the header revision, header signature, length
+ // Length of FvBlock cannot be 2**64-1
+ // HeaderLength cannot be an odd number
+ //
+ if ( (FwVolHeader->Revision != EFI_FVH_REVISION)
+ || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)
+ || (FwVolHeader->FvLength != FvLength)
+ )
+ {
+ DEBUG ((DEBUG_INFO, "%a: No Firmware Volume header present\n",
+ __FUNCTION__));
+ return EFI_NOT_FOUND;
+ }
+
+ // Check the Firmware Volume Guid
+ if (CompareGuid (&FwVolHeader->FileSystemGuid,
+ &gEfiSystemNvDataFvGuid) == FALSE ) {
+ DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\n",
+ __FUNCTION__));
+ return EFI_NOT_FOUND;
+ }
+
+ // Verify the header checksum
+ Checksum = CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader->HeaderLength);
+ if (Checksum != 0) {
+ DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n",
+ __FUNCTION__, Checksum));
+ return EFI_NOT_FOUND;
+ }
+
+ VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)FwVolHeader +
+ FwVolHeader->HeaderLength);
+
+ // Check the Variable Store Guid
+ if (!CompareGuid (&VariableStoreHeader->Signature,
+ &gEfiVariableGuid) &&
+ !CompareGuid (&VariableStoreHeader->Signature,
+ &gEfiAuthenticatedVariableGuid)) {
+ DEBUG ((DEBUG_INFO, "%a: Variable Store Guid non-compatible\n",
+ __FUNCTION__));
+ return EFI_NOT_FOUND;
+ }
+
+ VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) -
+ FwVolHeader->HeaderLength;
+ if (VariableStoreHeader->Size != VariableStoreLength) {
+ DEBUG ((DEBUG_INFO, "%a: Variable Store Length does not match\n",
+ __FUNCTION__));
+ return EFI_NOT_FOUND;
+ }
+
+ return EFI_SUCCESS;
+}
+
+/**
+ The GetAttributes() function retrieves the attributes and
+ current settings of the block.
+
+ @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+ @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and
+ current settings are returned.
+ Type EFI_FVB_ATTRIBUTES_2 is defined in
+ EFI_FIRMWARE_VOLUME_HEADER.
+
+ @retval EFI_SUCCESS The firmware volume attributes were returned.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbGetAttributes (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ OUT EFI_FVB_ATTRIBUTES_2 *Attributes
+ )
+{
+ EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes;
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) (
+
+ EFI_FVB2_READ_ENABLED_CAP |
+ // Reads may be enabled
+ EFI_FVB2_READ_STATUS |
+ // Reads are currently enabled
+ EFI_FVB2_WRITE_ENABLED_CAP |
+ // Writes may be enabled
+ EFI_FVB2_WRITE_STATUS |
+ // Writes are currently enabled
+ EFI_FVB2_STICKY_WRITE |
+ // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
+ EFI_FVB2_MEMORY_MAPPED |
+ // It is memory mapped
+ EFI_FVB2_ERASE_POLARITY
+ // After erasure all bits take this value (i.e. '1')
+
+ );
+
+ *Attributes = FlashFvbAttributes;
+
+ DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));
+
+ return EFI_SUCCESS;
+}
+
+/**
+ The SetAttributes() function sets configurable firmware volume attributes
+ and returns the new settings of the firmware volume.
+
+
+ @param This Indicates the
+ EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+ @param Attributes On input, Attributes is a pointer to
+ EFI_FVB_ATTRIBUTES_2 that contains the desired
+ firmware volume settings. On successful return,
+ it contains the new settings of the firmware
+ volume. Type EFI_FVB_ATTRIBUTES_2 is defined
+ in EFI_FIRMWARE_VOLUME_HEADER.
+
+ @retval EFI_SUCCESS The firmware volume attributes were returned.
+
+ @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with
+ the capabilities
+ as declared in the firmware volume header.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbSetAttributes (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
+ )
+{
+ DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes));
+ return EFI_UNSUPPORTED;
+}
+
+/**
+ The GetPhysicalAddress() function retrieves the base address of
+ a memory-mapped firmware volume. This function should be called
+ only for memory-mapped firmware volumes.
+
+ @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+ instance.
+
+ @param Address Pointer to a caller-allocated
+ EFI_PHYSICAL_ADDRESS that, on successful
+ return from GetPhysicalAddress(), contains the
+ base address of the firmware volume.
+
+ @retval EFI_SUCCESS The firmware volume base address was returned.
+
+ @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbGetPhysicalAddress (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ OUT EFI_PHYSICAL_ADDRESS *Address
+ )
+{
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n",
+ Instance->RegionBaseAddress));
+
+ ASSERT (Address != NULL);
+
+ *Address = mFlashNvStorageVariableBase;
+ return EFI_SUCCESS;
+}
+
+/**
+ The GetBlockSize() function retrieves the size of the requested
+ block. It also returns the number of additional blocks with
+ the identical size. The GetBlockSize() function is used to
+ retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
+
+
+ @param This Indicates the
+ EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
+
+ @param Lba Indicates the block for which to return
+ the size.
+
+ @param BlockSize Pointer to a caller-allocated UINTN in which
+ the size of the block is returned.
+
+ @param NumberOfBlocks Pointer to a caller-allocated UINTN in
+ which the number of consecutive blocks,
+ starting with Lba, is returned. All
+ blocks in this range have a size of
+ BlockSize.
+
+
+ @retval EFI_SUCCESS The firmware volume base address was returned.
+
+ @retval EFI_INVALID_PARAMETER The requested LBA is out of range.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbGetBlockSize (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ OUT UINTN *BlockSize,
+ OUT UINTN *NumberOfBlocks
+ )
+{
+ EFI_STATUS Status;
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n",
+ Lba, Instance->BlockSize, Instance->LastBlock));
+
+ if (Lba > Instance->LastBlock) {
+ DEBUG ((DEBUG_ERROR,
+ "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n",
+ Lba, Instance->LastBlock));
+ Status = EFI_INVALID_PARAMETER;
+ } else {
+ // This is easy because in this platform each NorFlash device
+ // has equal sized blocks.
+ *BlockSize = (UINTN) Instance->BlockSize;
+ *NumberOfBlocks = (UINTN) (Instance->LastBlock - Lba + 1);
+
+ DEBUG ((DEBUG_BLKIO,
+ "FvbGetBlockSize: *BlockSize=0x%x,*NumberOfBlocks=0x%x.\n",
+ *BlockSize, *NumberOfBlocks));
+
+ Status = EFI_SUCCESS;
+ }
+
+ return Status;
+}
+
+/**
+ Reads the specified number of bytes into a buffer from the specified block.
+
+ The Read() function reads the requested number of bytes from the
+ requested block and stores them in the provided buffer.
+ Implementations should be mindful that the firmware volume
+ might be in the ReadDisabled state. If it is in this state,
+ the Read() function must return the status code
+ EFI_ACCESS_DENIED without modifying the contents of the
+ buffer. The Read() function must also prevent spanning block
+ boundaries. If a read is requested that would span a block
+ boundary, the read must read up to the boundary but not
+ beyond. The output parameter NumBytes must be set to correctly
+ indicate the number of bytes actually read. The caller must be
+ aware that a read may be partially completed.
+
+ @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+ instance.
+
+ @param Lba The starting logical block index from which to read.
+
+ @param Offset Offset into the block at which to begin reading.
+
+ @param NumBytes Pointer to a UINTN.
+ At entry, *NumBytes contains the total size of the buffer.
+ At exit, *NumBytes contains the total number of bytes read.
+
+ @param Buffer Pointer to a caller-allocated buffer that will be used
+ to hold the data that is read.
+
+ @retval EFI_SUCCESS The firmware volume was read successfully,and contents are
+ in Buffer.
+
+ @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary.
+ On output, NumBytes contains the total number of bytes
+ returned in Buffer.
+
+ @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state.
+
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
+ could not be read.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbRead (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN OUT UINT8 *Buffer
+ )
+{
+ EFI_STATUS TempStatus;
+ UINTN BlockSize;
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ DEBUG ((DEBUG_BLKIO,
+ "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n",
+ Instance->StartLba + Lba, Offset, *NumBytes, Buffer));
+
+ TempStatus = EFI_SUCCESS;
+
+ // Cache the block size to avoid de-referencing pointers all the time
+ BlockSize = Instance->BlockSize;
+
+ DEBUG ((DEBUG_BLKIO,
+ "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n",
+ Offset, *NumBytes, BlockSize ));
+
+ // The read must not span block boundaries.
+ // We need to check each variable individually because adding two
+ // large values together overflows.
+ if ((Offset >= BlockSize) ||
+ (*NumBytes > BlockSize) ||
+ ((Offset + *NumBytes) > BlockSize)) {
+ DEBUG ((DEBUG_ERROR,
+ "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n",
+ Offset, *NumBytes, BlockSize ));
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // We must have some bytes to read
+ if (*NumBytes == 0) {
+ return EFI_BAD_BUFFER_SIZE;
+ }
+
+ // Decide if we are doing full block reads or not.
+ if (*NumBytes % BlockSize != 0) {
+ TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer);
+ if (EFI_ERROR (TempStatus)) {
+ return EFI_DEVICE_ERROR;
+ }
+ } else {
+ // Read NOR Flash data into shadow buffer
+ TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer);
+ if (EFI_ERROR (TempStatus)) {
+ // Return one of the pre-approved error statuses
+ return EFI_DEVICE_ERROR;
+ }
+ }
+ return EFI_SUCCESS;
+}
+
+/**
+ Writes the specified number of bytes from the input buffer to the block.
+
+ The Write() function writes the specified number of bytes from
+ the provided buffer to the specified block and offset. If the
+ firmware volume is sticky write, the caller must ensure that
+ all the bits of the specified range to write are in the
+ EFI_FVB_ERASE_POLARITY state before calling the Write()
+ function, or else the result will be unpredictable. This
+ unpredictability arises because, for a sticky-write firmware
+ volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY
+ state but cannot flip it back again. Before calling the
+ Write() function, it is recommended for the caller to first call
+ the EraseBlocks() function to erase the specified block to
+ write. A block erase cycle will transition bits from the
+ (NOT)EFI_FVB_ERASE_POLARITY state back to the
+ EFI_FVB_ERASE_POLARITY state. Implementations should be
+ mindful that the firmware volume might be in the WriteDisabled
+ state. If it is in this state, the Write() function must
+ return the status code EFI_ACCESS_DENIED without modifying the
+ contents of the firmware volume. The Write() function must
+ also prevent spanning block boundaries. If a write is
+ requested that spans a block boundary, the write must store up
+ to the boundary but not beyond. The output parameter NumBytes
+ must be set to correctly indicate the number of bytes actually
+ written. The caller must be aware that a write may be
+ partially completed. All writes, partial or otherwise, must be
+ fully flushed to the hardware before the Write() service
+ returns.
+
+ @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+ instance.
+
+ @param Lba The starting logical block index to write to.
+
+ @param Offset Offset into the block at which to begin writing.
+
+ @param NumBytes The pointer to a UINTN.
+ At entry, *NumBytes contains the total size of the
+ buffer.
+ At exit, *NumBytes contains the total number of
+ bytes actually written.
+
+ @param Buffer The pointer to a caller-allocated buffer that contains
+ the source for the write.
+
+ @retval EFI_SUCCESS The firmware volume was written successfully.
+
+ @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary.
+ On output, NumBytes contains the total number of bytes
+ actually written.
+
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.
+
+ @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not
+ be written.
+
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbWrite (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ IN EFI_LBA Lba,
+ IN UINTN Offset,
+ IN OUT UINTN *NumBytes,
+ IN UINT8 *Buffer
+ )
+{
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer);
+}
+
+/**
+ Erases and initialises a firmware volume block.
+
+ The EraseBlocks() function erases one or more blocks as denoted
+ by the variable argument list. The entire parameter list of
+ blocks must be verified before erasing any blocks. If a block is
+ requested that does not exist within the associated firmware
+ volume (it has a larger index than the last block of the
+ firmware volume), the EraseBlocks() function must return the
+ status code EFI_INVALID_PARAMETER without modifying the contents
+ of the firmware volume. Implementations should be mindful that
+ the firmware volume might be in the WriteDisabled state. If it
+ is in this state, the EraseBlocks() function must return the
+ status code EFI_ACCESS_DENIED without modifying the contents of
+ the firmware volume. All calls to EraseBlocks() must be fully
+ flushed to the hardware before the EraseBlocks() service
+ returns.
+
+ @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
+ instance.
+
+ @param ... The variable argument list is a list of tuples.
+ Each tuple describes a range of LBAs to erase
+ and consists of the following:
+ - An EFI_LBA that indicates the starting LBA
+ - A UINTN that indicates the number of blocks
+ to erase.
+
+ The list is terminated with an
+ EFI_LBA_LIST_TERMINATOR.
+ For example, the following indicates that two
+ ranges of blocks (5-7 and 10-11) are to be erased:
+ EraseBlocks (This, 5, 3, 10, 2,
+ EFI_LBA_LIST_TERMINATOR);
+
+ @retval EFI_SUCCESS The erase request successfully completed.
+
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.
+
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly
+ and could not be written.
+ The firmware device may have been partially erased.
+
+ @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable
+ argument list do not exist in the firmware volume.
+
+ **/
+EFI_STATUS
+EFIAPI
+FvbEraseBlocks (
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
+ ...
+ )
+{
+ EFI_STATUS Status;
+ VA_LIST Args;
+ UINTN BlockAddress; // Physical address of Lba to erase
+ EFI_LBA StartingLba; // Lba from which we start erasing
+ UINTN NumOfLba; // Number of Lba blocks to erase
+ NOR_FLASH_INSTANCE *Instance;
+
+ Instance = INSTANCE_FROM_FVB_THIS (This);
+
+ DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));
+
+ Status = EFI_SUCCESS;
+
+ // Before erasing, check the entire list of parameters to
+ // ensure all specified blocks are valid
+
+ VA_START (Args, This);
+ do {
+ // Get the Lba from which we start erasing
+ StartingLba = VA_ARG (Args, EFI_LBA);
+
+ // Have we reached the end of the list?
+ if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
+ //Exit the while loop
+ break;
+ }
+
+ // How many Lba blocks are we requested to erase?
+ NumOfLba = VA_ARG (Args, UINTN);
+
+ // All blocks must be within range
+ DEBUG ((
+ DEBUG_BLKIO,
+ "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n",
+ Instance->StartLba + StartingLba,
+ (UINT64)NumOfLba,
+ Instance->LastBlock
+ ));
+ if ((NumOfLba == 0) ||
+ ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->LastBlock)) {
+ VA_END (Args);
+ DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));
+ Status = EFI_INVALID_PARAMETER;
+ goto EXIT;
+ }
+ } while (TRUE);
+ VA_END (Args);
+
+ //
+ // To get here, all must be ok, so start erasing
+ //
+ VA_START (Args, This);
+ do {
+ // Get the Lba from which we start erasing
+ StartingLba = VA_ARG (Args, EFI_LBA);
+
+ // Have we reached the end of the list?
+ if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
+ // Exit the while loop
+ break;
+ }
+
+ // How many Lba blocks are we requested to erase?
+ NumOfLba = VA_ARG (Args, UINTN);
+
+ // Go through each one and erase it
+ while (NumOfLba > 0) {
+
+ // Get the physical address of Lba to erase
+ BlockAddress = GET_NOR_BLOCK_ADDRESS (
+ Instance->RegionBaseAddress,
+ Instance->StartLba + StartingLba,
+ Instance->BlockSize
+ );
+
+ // Erase it
+ DEBUG ((DEBUG_BLKIO,
+ "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n",
+ Instance->StartLba + StartingLba, BlockAddress));
+ Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
+ if (EFI_ERROR (Status)) {
+ VA_END (Args);
+ Status = EFI_DEVICE_ERROR;
+ goto EXIT;
+ }
+
+ // Move to the next Lba
+ StartingLba++;
+ NumOfLba--;
+ }
+ } while (TRUE);
+ VA_END (Args);
+
+EXIT:
+ return Status;
+}
diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c
new file mode 100644
index 0000000..08e20ae
--- /dev/null
+++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c
@@ -0,0 +1,250 @@
+/*++ @file NorFlashStandaloneMm.c
+
+ Copyright (c) 2019, ARM Ltd. All rights reserved.
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD
+ License which accompanies this distribution. The full text of the license
+ may be found at http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ --*/
+
+#include <PiMm.h>
+
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/PcdLib.h>
+
+#include "NorFlash.h"
+
+//
+// Global variable declarations
+//
+STATIC NOR_FLASH_INSTANCE **mNorFlashInstances;
+STATIC UINT32 mNorFlashDeviceCount;
+
+STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {
+ NOR_FLASH_SIGNATURE, // Signature
+ NULL, // Handle ... NEED TO BE FILLED
+
+ 0, // DeviceBaseAddress ... NEED TO BE FILLED
+ 0, // RegionBaseAddress ... NEED TO BE FILLED
+ 0, // Size ... NEED TO BE FILLED
+ 0, // BlockSize ... NEED TO BE FILLED
+ 0, // LastBlock ... NEED TO BE FILLED
+ 0, // StartLba ... NEED TO BE FILLED
+
+ {
+ FvbGetAttributes, // GetAttributes
+ FvbSetAttributes, // SetAttributes
+ FvbGetPhysicalAddress, // GetPhysicalAddress
+ FvbGetBlockSize, // GetBlockSize
+ FvbRead, // Read
+ FvbWrite, // Write
+ FvbEraseBlocks, // EraseBlocks
+ NULL, //ParentHandle
+ }, // FvbProtoccol;
+ NULL, // ShadowBuffer
+ {
+ {
+ {
+ HARDWARE_DEVICE_PATH,
+ HW_VENDOR_DP,
+ {
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),
+ (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)
+ }
+ },
+ { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } },
+ // GUID ... NEED TO BE FILLED
+ },
+ 0, // Index
+ {
+ END_DEVICE_PATH_TYPE,
+ END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
+ }
+ } // DevicePath
+};
+
+EFI_STATUS
+EFIAPI
+NorFlashFvbInitialize (
+ IN NOR_FLASH_INSTANCE* Instance
+ )
+{
+ EFI_STATUS Status;
+ UINT32 FvbNumLba;
+
+ DEBUG ((DEBUG_BLKIO,"NorFlashFvbInitialize\n"));
+ ASSERT ((Instance != NULL));
+
+ mFlashNvStorageVariableBase = FixedPcdGet32 (PcdFlashNvStorageVariableBase);
+
+ // Set the index of the first LBA for the FVB
+ Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) -
+ Instance->RegionBaseAddress) / Instance->BlockSize;
+
+ // Determine if there is a valid header at the beginning of the NorFlash
+ Status = ValidateFvHeader (Instance);
+
+ // Install the Default FVB header if required
+ if (EFI_ERROR (Status)) {
+ // There is no valid header, so time to install one.
+ DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));
+ DEBUG ((DEBUG_INFO, "%a: Installing a correct one for this volume.\n",
+ __FUNCTION__));
+
+ // Erase all the NorFlash that is reserved for variable storage
+ FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) +
+ PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
+ PcdGet32 (PcdFlashNvStorageFtwSpareSize)) /
+ Instance->BlockSize;
+
+ Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba,
+ EFI_LBA_LIST_TERMINATOR);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ // Install all appropriate headers
+ Status = InitializeFvAndVariableStoreHeaders (Instance);
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+ }
+
+ return Status;
+}
+
+VOID
+EFIAPI
+NorFlashLock (
+ NOR_FLASH_LOCK_CONTEXT *Context
+ )
+{
+}
+
+VOID
+EFIAPI
+NorFlashUnlock (
+ NOR_FLASH_LOCK_CONTEXT *Context
+ )
+{
+}
+
+EFI_STATUS
+NorFlashCreateInstance (
+ IN UINTN NorFlashDeviceBase,
+ IN UINTN NorFlashRegionBase,
+ IN UINTN NorFlashSize,
+ IN UINT32 Index,
+ IN UINT32 BlockSize,
+ IN BOOLEAN SupportFvb,
+ OUT NOR_FLASH_INSTANCE** NorFlashInstance
+ )
+{
+ EFI_STATUS Status;
+ NOR_FLASH_INSTANCE* Instance;
+
+ ASSERT (NorFlashInstance != NULL);
+
+ Instance = AllocateCopyPool (sizeof (NOR_FLASH_INSTANCE),
+ &mNorFlashInstanceTemplate);
+ if (Instance == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Instance->DeviceBaseAddress = NorFlashDeviceBase;
+ Instance->RegionBaseAddress = NorFlashRegionBase;
+ Instance->Size = NorFlashSize;
+
+ Instance->BlockSize = BlockSize;
+ Instance->LastBlock = (NorFlashSize / BlockSize)-1;
+
+ CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);
+ Instance->DevicePath.Index = (UINT8)Index;
+
+ NorFlashReset (Instance);
+
+ Instance->ShadowBuffer = AllocatePool (BlockSize);;
+ if (Instance->ShadowBuffer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ if (SupportFvb) {
+ NorFlashFvbInitialize (Instance);
+
+ //Install FirmwareVolumeBlock Protocol
+ Status = gMmst->MmInstallProtocolInterface (
+ &Instance->Handle,
+ &gEfiSmmFirmwareVolumeBlockProtocolGuid,
+ EFI_NATIVE_INTERFACE,
+ &Instance->FvbProtocol
+ );
+ if (EFI_ERROR (Status)) {
+ FreePool (Instance);
+ return Status;
+ }
+ }
+
+ *NorFlashInstance = Instance;
+ return Status;
+}
+
+EFI_STATUS
+EFIAPI
+NorFlashInitialise (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_MM_SYSTEM_TABLE *SystemTable
+ )
+{
+ EFI_STATUS Status;
+ UINT32 Index;
+ NOR_FLASH_DESCRIPTION* NorFlashDevices;
+ BOOLEAN ContainVariableStorage;
+
+ Status = NorFlashPlatformInitialization ();
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
+ return Status;
+ }
+
+ Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));
+ return Status;
+ }
+
+ mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE*) * mNorFlashDeviceCount);
+
+ for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
+ // Check if this NOR Flash device contain the variable storage region
+ ContainVariableStorage =
+ (NorFlashDevices[Index].RegionBaseAddress <=
+ PcdGet32 (PcdFlashNvStorageVariableBase)) &&
+ (PcdGet32 (PcdFlashNvStorageVariableBase) +
+ PcdGet32 (PcdFlashNvStorageVariableSize) <=
+ NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
+
+ Status = NorFlashCreateInstance (
+ NorFlashDevices[Index].DeviceBaseAddress,
+ NorFlashDevices[Index].RegionBaseAddress,
+ NorFlashDevices[Index].Size,
+ Index,
+ NorFlashDevices[Index].BlockSize,
+ ContainVariableStorage,
+ &mNorFlashInstances[Index]
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR,
+ "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));
+ }
+ }
+ return Status;
+}
diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf
new file mode 100644
index 0000000..12073fc
--- /dev/null
+++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf
@@ -0,0 +1,68 @@
+#/** @file
+#
+# Component description file for NorFlashStandaloneMm module
+#
+# Copyright (c) 2019, ARM Ltd. All rights reserved.<BR>
+#
+# This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#**/
+
+[Defines]
+ INF_VERSION = 0x00010005
+ BASE_NAME = StandaloneMmNorFlash
+ FILE_GUID = 166F677B-DAC9-4AE4-AD34-2FF2504B0637
+ MODULE_TYPE = MM_STANDALONE
+ VERSION_STRING = 1.0
+ PI_SPECIFICATION_VERSION = 0x00010032
+ ENTRY_POINT = NorFlashInitialise
+
+[Sources.common]
+ NorFlash.c
+ NorFlashFvb.c
+ NorFlashStandaloneMm.c
+
+[Packages]
+ ArmPkg/ArmPkg.dec
+ ArmPlatformPkg/ArmPlatformPkg.dec
+ MdePkg/MdePkg.dec
+ MdeModulePkg/MdeModulePkg.dec
+ StandaloneMmPkg/StandaloneMmPkg.dec
+
+[LibraryClasses]
+ ArmLib
+ ArmSvcLib
+ BaseMemoryLib
+ BaseLib
+ DebugLib
+ MemoryAllocationLib
+ MmServicesTableLib
+ NorFlashPlatformLib
+ StandaloneMmDriverEntryPoint
+
+[Guids]
+ gEfiSystemNvDataFvGuid
+ gEfiVariableGuid
+ gEfiAuthenticatedVariableGuid
+
+[Protocols]
+ gEfiSmmFirmwareVolumeBlockProtocolGuid
+
+[Pcd.common]
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase
+ gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
+
+ gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked
+
+[Depex]
+ TRUE
--
2.7.4
^ permalink raw reply related [flat|nested] 10+ messages in thread[parent not found: <CADpYukZHE6NY-U=EycJBVGbQ-XcxXpeT9w6svzWMePjvQXFciQ@mail.gmail.com>]
* Re: [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver [not found] ` <CADpYukZHE6NY-U=EycJBVGbQ-XcxXpeT9w6svzWMePjvQXFciQ@mail.gmail.com> @ 2019-04-24 9:05 ` jagadeesh.ujja 2019-04-24 13:06 ` [edk2-devel] " Ard Biesheuvel 0 siblings, 1 reply; 10+ messages in thread From: jagadeesh.ujja @ 2019-04-24 9:05 UTC (permalink / raw) To: Leif Lindholm, Ard Biesheuvel, devel Fwd to new EDKII development mailing list. hi Ard, Sorry about missing your previous comment and adding here. "Hello Jagadeesh, Why are you moving this driver into edk2-platforms? I'd prefer to have it alongside the non-MM version instead. That would allow us to share a lot more code between the two versions." ----------------- my Point of view: In ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and disk I/O protocols. In case of StandaloneMM norflash driver the block I/O and disk I/O protocols are not required We don’t want to remove support of block I/O and disk I/O protocols in “ArmPlatformPkg/Drivers/NorFlashDxe” In this case “NOR_FLASH_INSTANCE” is different in both drivers(DXE/STANDALONEMM). So we end up with having 2 different drivers. Even if we want to share common code then we end up with multiple files as “NOR_FLASH_INSTANCE” is used in almost all files Ex: “NorFlash.c” “NorFlash.h” NorFlashFvb.c In this case “NorFlash.c” will have 2 copies one used by DXE and other by STANDALONE_MM driver So instead of having 2 different drivers in one place “ArmPlatformPkg/Drivers/NorFlashDxe” added a new refactored nor flash driver in "Platform/ARM/Drivers" I am not sure if any other platform is using “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and disk I/O protocols if we remove “support of block I/O and disk I/O protocols” then we can share the common code easily. thanks Jagadeesh On Mon, Apr 8, 2019 at 7:16 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > hi Ard/Leif > > Please let me know if you have any comments on this patch set > thanks > Jagadeesh > > On Tue, Apr 2, 2019 at 6:48 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > Refactor the existing ArmPlatformPkg NOR flash driver to be usable > > as a StandaloneMM library. Some of the functionality not required > > in StandaloneMM, such as the block layer, is removed. This allows > > storing of EFI variables on NOR flash which is accessible only via > > the MM STANDALONE mode software > > > > Contributed-under: TianoCore Contribution Agreement 1.1 > > Signed-off-by: Jagadeesh Ujja <jagadeesh.ujja@arm.com> > > --- > > Changes since v1: > > - This is a next version of patch > > “[edk2] [PATCH 0/2] Allow use of ArmPlatformPkg NOR flash driver in StandaloneMM” > > https://lists.01.org/pipermail/edk2-devel/2019-February/036882.html > > https://lists.01.org/pipermail/edk2-devel/2019-February/036884.html > > https://lists.01.org/pipermail/edk2-devel/2019-February/036883.html > > - ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and disk > > I/O protocols. This driver is required in StandaloneMM but the block I/O > > and disk I/O protocols are not required in StandaloneMM. > > - Instead of removing support for block I/O and disk I/O protocols, > > add a new refactored nor flash driver in "Platform/ARM/Drivers" > > - Addressed all the comments from Ard Biesheuvel. > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c | 982 ++++++++++++++++++++ > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h | 326 +++++++ > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c | 740 +++++++++++++++ > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c | 250 +++++ > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf | 68 ++ > > 5 files changed, 2366 insertions(+) > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > new file mode 100644 > > index 0000000..4ba4fb5 > > --- /dev/null > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > @@ -0,0 +1,982 @@ > > +/** @file NorFlash.c > > + > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > + > > + This program and the accompanying materials > > + are licensed and made available under the terms and conditions of the > > + BSD License which accompanies this distribution. The full text of the > > + license may be found at http://opensource.org/licenses/bsd-license.php > > + > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > + > > +**/ > > + > > +#include <Library/BaseMemoryLib.h> > > +#include <Library/MemoryAllocationLib.h> > > +#include <Library/PcdLib.h> > > +#include <Library/UefiLib.h> > > + > > +#include "NorFlash.h" > > + > > +STATIC > > +UINT32 > > +NorFlashReadStatusRegister ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN SR_Address > > + ) > > +{ > > + // Prepare to read the status register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER); > > + return MmioRead32 (Instance->DeviceBaseAddress); > > +} > > + > > +STATIC > > +BOOLEAN > > +NorFlashBlockIsLocked ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + UINT32 LockStatus; > > + > > + // Send command for reading device id > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > + > > + // Read block lock status > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > + > > + // Decode block lock status > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > + > > + if ((LockStatus & 0x2) != 0) { > > + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n")); > > + } > > + > > + return ((LockStatus & 0x1) != 0); > > +} > > + > > +STATIC > > +EFI_STATUS > > +NorFlashUnlockSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + UINT32 LockStatus; > > + > > + // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations > > + // and to protect shared data structures. > > + > > + if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) { > > + do { > > + // Request a lock setup > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > + > > + // Request an unlock > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > + > > + // Send command for reading device id > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > + > > + // Read block lock status > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > + > > + // Decode block lock status > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > + } while ((LockStatus & 0x1) == 1); > > + } else { > > + // Request a lock setup > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > + > > + // Request an unlock > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > + > > + // Wait until the status register gives us the all clear > > + do { > > + LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress); > > + } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY); > > + > > + DEBUG ((DEBUG_BLKIO, > > + "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress)); > > + > > + return EFI_SUCCESS; > > +} > > + > > +STATIC > > +EFI_STATUS > > +NorFlashUnlockSingleBlockIfNecessary ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + > > + Status = EFI_SUCCESS; > > + > > + if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) { > > + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress); > > + } > > + > > + return Status; > > +} > > + > > +/** > > + * The following function presumes that the block has already been unlocked. > > + **/ > > +STATIC > > +EFI_STATUS > > +NorFlashEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 StatusRegister; > > + > > + Status = EFI_SUCCESS; > > + > > + // Request a block erase and then confirm it > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP); > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM); > > + > > + // Wait until the status register gives us the all clear > > + do { > > + StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress); > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR, > > + "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == > > + (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) { > > + DEBUG ((DEBUG_ERROR, > > + "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", > > + BlockAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_ERASE) { > > + DEBUG ((DEBUG_ERROR, > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", > > + BlockAddress, StatusRegister)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + // The debug level message has been reduced because a device > > + // lock might happen. In this case we just retry it ... > > + DEBUG ((DEBUG_INFO, > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", > > + BlockAddress)); > > + Status = EFI_WRITE_PROTECTED; > > + } > > + > > + if (EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +/** > > + * This function unlock and erase an entire NOR Flash block. > > + **/ > > +EFI_STATUS > > +NorFlashUnlockAndEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN Index; > > + NOR_FLASH_LOCK_CONTEXT Lock; > > + > > + NorFlashLock (&Lock); > > + > > + Index = 0; > > + // The block erase might fail a first time (SW bug ?). Retry it ... > > + do { > > + // Unlock the block if we have to > > + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + break; > > + } > > + Status = NorFlashEraseSingleBlock (Instance, BlockAddress); > > + Index++; > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED)); > > + > > + if (Index == NOR_FLASH_ERASE_RETRY) { > > + DEBUG ((DEBUG_ERROR, > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", > > + BlockAddress,Index)); > > + } > > + > > + NorFlashUnlock (&Lock); > > + > > + return Status; > > +} > > + > > +STATIC > > +EFI_STATUS > > +NorFlashWriteSingleWord ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN WordAddress, > > + IN UINT32 WriteData > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 StatusRegister; > > + > > + Status = EFI_SUCCESS; > > + > > + // Request a write single word command > > + SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP); > > + > > + // Store the word into NOR Flash; > > + MmioWrite32 (WordAddress, WriteData); > > + > > + // Wait for the write to complete and then check for any errors; > > + // i.e. check the Status Register > > + do { > > + // Prepare to read the status register > > + StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress); > > + // The chip is busy while the WRITE bit is not asserted > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + > > + // Perform a full status check: > > + // Mask the relevant bits of Status Register. > > + // Everything should be zero, if not, we have a problem > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", > > + WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", > > + WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", > > + WordAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (!EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, > > + 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +/* > > + * Writes data to the NOR Flash using the Buffered Programming method. > > + * > > + * The maximum size of the on-chip buffer is 32-words, because of hardware > > + * restrictions. Therefore this function will only handle buffers up to 32 > > + * words or 128 bytes. To deal with larger buffers, call this function again. > > + * > > + * This function presumes that both the TargetAddress and the > > + * TargetAddress+BufferSize exist entirely within the NOR Flash. > > + * Therefore these conditions will not be checked here. > > + * > > + * In buffered programming, if the target address not at the beginning of a > > + * 32-bit word boundary,then programming time is doubled and power consumption > > + * is increased. Therefore, it is a requirement to align buffer writes to > > + * 32-bit word boundaries. > > + * i.e. the last 4 bits of the target start address must be zero: 0x......00 > > + */ > > +EFI_STATUS > > +NorFlashWriteBuffer ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN TargetAddress, > > + IN UINTN BufferSizeInBytes, > > + IN UINT32 *Buffer > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN BufferSizeInWords; > > + UINTN Count; > > + volatile UINT32 *Data; > > + UINTN WaitForBuffer; > > + BOOLEAN BufferAvailable; > > + UINT32 StatusRegister; > > + > > + WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS; > > + BufferAvailable = FALSE; > > + > > + // Check that the target address does not cross a 32-word boundary. > > + if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Check there are some data to program > > + if (BufferSizeInBytes == 0) { > > + return EFI_BUFFER_TOO_SMALL; > > + } > > + > > + // Check that the buffer size does not exceed the maximum hardware buffer > > + // size on chip. > > + if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Check that the buffer size is a multiple of 32-bit words > > + if ((BufferSizeInBytes % 4) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Pre-programming conditions checked, now start the algorithm. > > + > > + // Prepare the data destination address > > + Data = (UINT32 *)TargetAddress; > > + > > + // Check the availability of the buffer > > + do { > > + // Issue the Buffered Program Setup command > > + SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP); > > + > > + // Read back the status register bit#7 from the same address > > + if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) { > > + BufferAvailable = TRUE; > > + } > > + > > + // Update the loop counter > > + WaitForBuffer--; > > + > > + } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE)); > > + > > + // The buffer was not available for writing > > + if (WaitForBuffer == 0) { > > + Status = EFI_DEVICE_ERROR; > > + goto EXIT; > > + } > > + > > + // From now on we work in 32-bit words > > + BufferSizeInWords = BufferSizeInBytes / (UINTN)4; > > + > > + // Write the word count, which is (buffer_size_in_words - 1), > > + // because word count 0 means one word. > > + SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1)); > > + > > + // Write the data to the NOR Flash, advancing each address by 4 bytes > > + for (Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) { > > + MmioWrite32 ((UINTN)Data, *Buffer); > > + } > > + > > + // Issue the Buffered Program Confirm command, to start the programming operation > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM); > > + > > + // Wait for the write to complete and then check for any errors; > > + // i.e. check the Status Register > > + do { > > + StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress); > > + // The chip is busy while the WRITE bit is not asserted > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > + > > + > > + // Perform a full status check: > > + // Mask the relevant bits of Status Register. > > + // Everything should be zero, if not, we have a problem > > + > > + Status = EFI_SUCCESS; > > + > > + if (StatusRegister & P30_SR_BIT_VPP) { > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): VPP Range Error\n", > > + TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Program Error\n", > > + TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Device Protect Error\n", > > + TargetAddress)); > > + Status = EFI_DEVICE_ERROR; > > + } > > + > > + if (!EFI_ERROR (Status)) { > > + // Clear the Status Register > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > + } > > + > > +EXIT: > > + // Put device back into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + return Status; > > +} > > + > > +STATIC > > +EFI_STATUS > > +NorFlashWriteFullBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINT32 *DataBuffer, > > + IN UINT32 BlockSizeInWords > > + ) > > +{ > > + EFI_STATUS Status; > > + UINTN WordAddress; > > + UINT32 WordIndex; > > + UINTN BufferIndex; > > + UINTN BlockAddress; > > + UINTN BuffersInBlock; > > + UINTN RemainingWords; > > + UINTN Cnt; > > + NOR_FLASH_LOCK_CONTEXT Lock; > > + > > + Status = EFI_SUCCESS; > > + > > + // Get the physical address of the block > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4); > > + > > + // Start writing from the first address at the start of the block > > + WordAddress = BlockAddress; > > + > > + NorFlashLock (&Lock); > > + > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, > > + "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", > > + BlockAddress)); > > + goto EXIT; > > + } > > + > > + // To speed up the programming operation, NOR Flash is programmed using the > > + // Buffered Programming method. > > + > > + // Check that the address starts at a 32-word boundary, > > + // i.e. last 7 bits must be zero > > + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) { > > + > > + // First, break the entire block into buffer-sized chunks. > > + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES; > > + > > + // Then feed each buffer chunk to the NOR Flash > > + // If a buffer does not contain any data, don't write it. > > + for (BufferIndex=0; > > + BufferIndex < BuffersInBlock; > > + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, > > + DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS > > + ) { > > + // Check the buffer to see if it contains any data (not set all 1s). > > + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) { > > + if (~DataBuffer[Cnt] != 0 ) { > > + // Some data found, write the buffer. > > + Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, > > + DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + break; > > + } > > + } > > + } > > + > > + // Finally, finish off any remaining words that are less than the > > + // maximum size of the buffer > > + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS; > > + > > + if (RemainingWords != 0) { > > + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + > > + } else { > > + // For now, use the single word programming algorithm > > + // It is unlikely that the NOR Flash will exist in an address which falls > > + // within a 32 word boundary range, > > + // i.e. which ends in the range 0x......01 - 0x......7F. > > + for (WordIndex=0; > > + WordIndex<BlockSizeInWords; > > + WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) { > > + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer); > > + if (EFI_ERROR (Status)) { > > + goto EXIT; > > + } > > + } > > + } > > + > > +EXIT: > > + NorFlashUnlock (&Lock); > > + > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, > > + "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", > > + WordAddress, Status)); > > + } > > + return Status; > > +} > > + > > +EFI_STATUS > > +NorFlashWriteBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ) > > +{ > > + UINT32 *pWriteBuffer; > > + EFI_STATUS Status = EFI_SUCCESS; > > + EFI_LBA CurrentBlock; > > + UINT32 BlockSizeInWords; > > + UINT32 NumBlocks; > > + UINT32 BlockCount; > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // We must have some bytes to read > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes)); > > + if (BufferSizeInBytes == 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // The size of the buffer must be a multiple of the block size > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->BlockSize)); > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // All blocks must be within the device > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > + > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", > > + NumBlocks, Instance->LastBlock, Lba)); > > + > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + BlockSizeInWords = Instance->BlockSize / 4; > > + > > + // Because the target *Buffer is a pointer to VOID, we must put all the > > + // data into a pointer to a proper data type, so use *ReadBuffer > > + pWriteBuffer = (UINT32 *)Buffer; > > + > > + CurrentBlock = Lba; > > + for (BlockCount=0; > > + BlockCount < NumBlocks; > > + BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) { > > + > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock)); > > + > > + Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords); > > + > > + if (EFI_ERROR (Status)) { > > + break; > > + } > > + } > > + > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status)); > > + return Status; > > +} > > + > > +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0) > > + > > +/** > > + Copy Length bytes from Source to Destination, using aligned accesses only. > > + Note that this implementation uses memcpy() semantics rather then memmove() > > + semantics, i.e., SourceBuffer and DestinationBuffer should not overlap. > > + > > + @param DestinationBuffer The target of the copy request. > > + @param SourceBuffer The place to copy from. > > + @param Length The number of bytes to copy. > > + > > + @return Destination > > + > > +**/ > > +STATIC > > +VOID * > > +AlignedCopyMem ( > > + OUT VOID *DestinationBuffer, > > + IN CONST VOID *SourceBuffer, > > + IN UINTN Length > > + ) > > +{ > > + UINT8 *Destination8; > > + CONST UINT8 *Source8; > > + UINT32 *Destination32; > > + CONST UINT32 *Source32; > > + UINT64 *Destination64; > > + CONST UINT64 *Source64; > > + > > + if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && Length >= 8) { > > + Destination64 = DestinationBuffer; > > + Source64 = SourceBuffer; > > + while (Length >= 8) { > > + *Destination64++ = *Source64++; > > + Length -= 8; > > + } > > + > > + Destination8 = (UINT8 *)Destination64; > > + Source8 = (CONST UINT8 *)Source64; > > + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && Length >= 4) { > > + Destination32 = DestinationBuffer; > > + Source32 = SourceBuffer; > > + while (Length >= 4) { > > + *Destination32++ = *Source32++; > > + Length -= 4; > > + } > > + > > + Destination8 = (UINT8 *)Destination32; > > + Source8 = (CONST UINT8 *)Source32; > > + } else { > > + Destination8 = DestinationBuffer; > > + Source8 = SourceBuffer; > > + } > > + while (Length-- != 0) { > > + *Destination8++ = *Source8++; > > + } > > + return DestinationBuffer; > > +} > > + > > +EFI_STATUS > > +NorFlashReadBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ) > > +{ > > + UINT32 NumBlocks; > > + UINTN StartAddress; > > + > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n", > > + BufferSizeInBytes, Instance->BlockSize, Instance->LastBlock, Lba)); > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Return if we have not any byte to read > > + if (BufferSizeInBytes == 0) { > > + return EFI_SUCCESS; > > + } > > + > > + // The size of the buffer must be a multiple of the block size > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // All blocks must be within the device > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > + > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashReadBlocks: ERROR - Read will exceed last block\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Get the address to start reading from > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > + Lba, > > + Instance->BlockSize > > + ); > > + > > + // Put the device into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + // Readout the data > > + AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes); > > + > > + return EFI_SUCCESS; > > +} > > + > > +EFI_STATUS > > +NorFlashRead ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ) > > +{ > > + UINTN StartAddress; > > + > > + // The buffer must be valid > > + if (Buffer == NULL) { > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Return if we have not any byte to read > > + if (BufferSizeInBytes == 0) { > > + return EFI_SUCCESS; > > + } > > + > > + if (((Lba * Instance->BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) { > > + DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n")); > > + return EFI_INVALID_PARAMETER; > > + } > > + > > + // Get the address to start reading from > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > + Lba, > > + Instance->BlockSize > > + ); > > + > > + // Put the device into Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + > > + // Readout the data > > + AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes); > > + > > + return EFI_SUCCESS; > > +} > > + > > +/* > > + Write a full or portion of a block. It must not span block boundaries; > > + that is, Offset + *NumBytes <= Instance->Media.BlockSize. > > +*/ > > +EFI_STATUS > > +NorFlashWriteSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ) > > +{ > > + EFI_STATUS TempStatus; > > + UINT32 Tmp; > > + UINT32 TmpBuf; > > + UINT32 WordToWrite; > > + UINT32 Mask; > > + BOOLEAN DoErase; > > + UINTN BytesToWrite; > > + UINTN CurOffset; > > + UINTN WordAddr; > > + UINTN BlockSize; > > + UINTN BlockAddress; > > + UINTN PrevBlockAddress; > > + > > + PrevBlockAddress = 0; > > + > > + DEBUG ((DEBUG_BLKIO, > > + "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > + Lba, Offset, *NumBytes, Buffer)); > > + > > + // Cache the block size to avoid de-referencing pointers all the time > > + BlockSize = Instance->BlockSize; > > + > > + // The write must not span block boundaries. > > + // We need to check each variable individually because adding two > > + // large values together overflows. > > + if ( ( Offset >= BlockSize ) || > > + ( *NumBytes > BlockSize ) || > > + ( (Offset + *NumBytes) > BlockSize ) ) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > + Offset, *NumBytes, BlockSize )); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // We must have some bytes to write > > + if (*NumBytes == 0) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > + Offset, *NumBytes, BlockSize )); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Pick 128bytes as a good start for word operations as opposed to erasing the > > + // block and writing the data regardless if an erase is really needed. > > + // It looks like most individual NV variable writes are smaller than 128bytes. > > + if (*NumBytes <= 128) { > > + // Check to see if we need to erase before programming the data into NOR. > > + // If the destination bits are only changing from 1s to 0s we can just write. > > + // After a block is erased all bits in the block is set to 1. > > + // If any byte requires us to erase we just give up and rewrite all of it. > > + DoErase = FALSE; > > + BytesToWrite = *NumBytes; > > + CurOffset = Offset; > > + > > + while (BytesToWrite > 0) { > > + // Read full word from NOR, splice as required. A word is the smallest > > + // unit we can write. > > + TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Physical address of word in NOR to write. > > + WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > + Lba, BlockSize); > > + // The word of data that is to be written. > > + TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite))); > > + > > + // First do word aligned chunks. > > + if ((CurOffset & 0x3) == 0) { > > + if (BytesToWrite >= 4) { > > + // Is the destination still in 'erased' state? > > + if (~Tmp != 0) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + // Write this word to NOR > > + WordToWrite = TmpBuf; > > + CurOffset += sizeof (TmpBuf); > > + BytesToWrite -= sizeof (TmpBuf); > > + } else { > > + // BytesToWrite < 4. Do small writes and left-overs > > + Mask = ~((~0) << (BytesToWrite * 8)); > > + // Mask out the bytes we want. > > + TmpBuf &= Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + CurOffset += BytesToWrite; > > + BytesToWrite = 0; > > + } > > + } else { > > + // Do multiple words, but starting unaligned. > > + if (BytesToWrite > (4 - (CurOffset & 0x3))) { > > + Mask = ((~0) << ((CurOffset & 0x3) * 8)); > > + // Mask out the bytes we want. > > + TmpBuf &= Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + BytesToWrite -= (4 - (CurOffset & 0x3)); > > + CurOffset += (4 - (CurOffset & 0x3)); > > + } else { > > + // Unaligned and fits in one word. > > + Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8); > > + // Mask out the bytes we want. > > + TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask; > > + // Is the destination still in 'erased' state? > > + if ((Tmp & Mask) != Mask) { > > + // Check to see if we are only changing bits to zero. > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > + DoErase = TRUE; > > + break; > > + } > > + } > > + // Merge old and new data. Write merged word to NOR > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > + CurOffset += BytesToWrite; > > + BytesToWrite = 0; > > + } > > + } > > + > > + // > > + // Write the word to NOR. > > + // > > + > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize); > > + if (BlockAddress != PrevBlockAddress) { > > + TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + PrevBlockAddress = BlockAddress; > > + } > > + TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + } > > + // Exit if we got here and could write all the data. Otherwise do the > > + // Erase-Write cycle. > > + if (!DoErase) { > > + return EFI_SUCCESS; > > + } > > + } > > + > > + // Check we did get some memory. Buffer is BlockSize. > > + if (Instance->ShadowBuffer == NULL) { > > + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n")); > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Read NOR Flash data into shadow buffer > > + TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + > > + // Put the data at the appropriate location inside the buffer area > > + CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes); > > + > > + // Write the modified buffer back to the NorFlash > > + TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + > > + return EFI_SUCCESS; > > +} > > + > > +EFI_STATUS > > +NorFlashReset ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + // As there is no specific RESET to perform, ensure that the devices > > + // is in the default Read Array mode > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > + return EFI_SUCCESS; > > +} > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > new file mode 100644 > > index 0000000..0396f7a > > --- /dev/null > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > @@ -0,0 +1,326 @@ > > +/** @file NorFlash.h > > + > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > + > > + This program and the accompanying materials > > + are licensed and made available under the terms and conditions of the BSD > > + License which accompanies this distribution. The full text of the license > > + may be found at http://opensource.org/licenses/bsd-license.php > > + > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > + > > +**/ > > + > > +#ifndef __NOR_FLASH_H__ > > +#define __NOR_FLASH_H__ > > + > > +#include <Base.h> > > +#include <Guid/EventGroup.h> > > +#include <Library/DebugLib.h> > > +#include <Library/IoLib.h> > > +#include <Library/MmServicesTableLib.h> > > +#include <Library/NorFlashPlatformLib.h> > > +#include <Library/UefiLib.h> > > +#include <Library/UefiRuntimeLib.h> > > +#include <Protocol/FirmwareVolumeBlock.h> > > + > > +#define NOR_FLASH_ERASE_RETRY 10 > > + > > +// Device access macros > > +// These are necessary because we use 2 x 16bit parts to make up 32bit data > > + > > +#define HIGH_16_BITS 0xFFFF0000 > > +#define LOW_16_BITS 0x0000FFFF > > +#define LOW_8_BITS 0x000000FF > > + > > +#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | \ > > + ( value & LOW_16_BITS ) ) > > + > > +#define GET_LOW_BYTE(value) ( value & LOW_8_BITS ) > > +#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE ( value >> 16 ) ) > > + > > +// Each command must be sent simultaneously to both chips, > > +// i.e. at the lower 16 bits AND at the higher 16 bits > > +#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr) ( ( BaseAddr ) + \ > > + ( ( OffsetAddr ) << 2)) > > +#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16 ) | \ > > + ( Cmd & LOW_16_BITS ) ) > > +#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 \ > > + ( CREATE_NOR_ADDRESS ( BaseAddr,Offset ), \ > > + CREATE_DUAL_CMD ( Cmd) ) > > +#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + \ > > + ( UINTN )( ( Lba ) * LbaSize ) ) > > + > > +// Status Register Bits > > +#define P30_SR_BIT_WRITE ( BIT7 << 16 | BIT7 ) > > +#define P30_SR_BIT_ERASE_SUSPEND ( BIT6 << 16 | BIT6 ) > > +#define P30_SR_BIT_ERASE ( BIT5 << 16 | BIT5 ) > > +#define P30_SR_BIT_PROGRAM ( BIT4 << 16 | BIT4 ) > > +#define P30_SR_BIT_VPP ( BIT3 << 16 | BIT3 ) > > +#define P30_SR_BIT_PROGRAM_SUSPEND ( BIT2 << 16 | BIT2 ) > > +#define P30_SR_BIT_BLOCK_LOCKED ( BIT1 << 16 | BIT1 ) > > +#define P30_SR_BIT_BEFP ( BIT0 << 16 | BIT0 ) > > + > > +// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family > > + > > +// On chip buffer size for buffered programming operations > > +// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each > > +// word is 2 bytes. > > +// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes > > +#define P30_MAX_BUFFER_SIZE_IN_BYTES ( ( UINTN ) 128 ) > > +#define P30_MAX_BUFFER_SIZE_IN_WORDS ( P30_MAX_BUFFER_SIZE_IN_BYTES/ ( ( UINTN) 4 ) ) > > +#define MAX_BUFFERED_PROG_ITERATIONS 10000000 > > +#define BOUNDARY_OF_32_WORDS 0x7F > > + > > +// CFI Addresses > > +#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10 > > +#define P30_CFI_ADDR_VENDOR_ID 0x13 > > + > > +// CFI Data > > +#define CFI_QRY 0x00595251 > > + > > +// READ Commands > > +#define P30_CMD_READ_DEVICE_ID 0x0090 > > +#define P30_CMD_READ_STATUS_REGISTER 0x0070 > > +#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050 > > +#define P30_CMD_READ_ARRAY 0x00FF > > +#define P30_CMD_READ_CFI_QUERY 0x0098 > > + > > +// WRITE Commands > > +#define P30_CMD_WORD_PROGRAM_SETUP 0x0040 > > +#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010 > > +#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8 > > +#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0 > > +#define P30_CMD_BEFP_SETUP 0x0080 > > +#define P30_CMD_BEFP_CONFIRM 0x00D0 > > + > > +// ERASE Commands > > +#define P30_CMD_BLOCK_ERASE_SETUP 0x0020 > > +#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0 > > + > > +// SUSPEND Commands > > +#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0 > > +#define P30_CMD_SUSPEND_RESUME 0x00D0 > > + > > +// BLOCK LOCKING / UNLOCKING Commands > > +#define P30_CMD_LOCK_BLOCK_SETUP 0x0060 > > +#define P30_CMD_LOCK_BLOCK 0x0001 > > +#define P30_CMD_UNLOCK_BLOCK 0x00D0 > > +#define P30_CMD_LOCK_DOWN_BLOCK 0x002F > > + > > +// PROTECTION Commands > > +#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0 > > + > > +// CONFIGURATION Commands > > +#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060 > > +#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003 > > + > > +#define NOR_FLASH_SIGNATURE SIGNATURE_32 ('n', 'o', 'r', '0') > > +#define INSTANCE_FROM_FVB_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > + FvbProtocol, \ > > + NOR_FLASH_SIGNATURE) > > +#define INSTANCE_FROM_BLKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > + BlockIoProtocol, \ > > + NOR_FLASH_SIGNATURE) > > +#define INSTANCE_FROM_DISKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > + DiskIoProtocol, \ > > + NOR_FLASH_SIGNATURE) > > + > > +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE; > > +extern UINTN mFlashNvStorageVariableBase; > > + > > +#pragma pack (1) > > +typedef struct { > > + VENDOR_DEVICE_PATH Vendor; > > + UINT8 Index; > > + EFI_DEVICE_PATH_PROTOCOL End; > > +} NOR_FLASH_DEVICE_PATH; > > +#pragma pack () > > + > > +struct _NOR_FLASH_INSTANCE { > > + UINT32 Signature; > > + EFI_HANDLE Handle; > > + > > + UINTN DeviceBaseAddress; > > + UINTN RegionBaseAddress; > > + UINTN Size; > > + UINT32 BlockSize; > > + UINT32 LastBlock; > > + EFI_LBA StartLba; > > + > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol; > > + VOID* ShadowBuffer; > > + > > + NOR_FLASH_DEVICE_PATH DevicePath; > > +}; > > + > > +EFI_STATUS > > +NorFlashWriteBuffer ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN TargetAddress, > > + IN UINTN BufferSizeInBytes, > > + IN UINT32 *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashCreateInstance ( > > + IN UINTN NorFlashDeviceBase, > > + IN UINTN NorFlashRegionBase, > > + IN UINTN NorFlashSize, > > + IN UINT32 Index, > > + IN UINT32 BlockSize, > > + IN BOOLEAN SupportFvb, > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE* Instance > > + ); > > + > > +EFI_STATUS > > +ValidateFvHeader ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +EFI_STATUS > > +InitializeFvAndVariableStoreHeaders ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE* Instance > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbSetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetPhysicalAddress ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_PHYSICAL_ADDRESS *Address > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbGetBlockSize ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + OUT UINTN *BlockSize, > > + OUT UINTN *NumberOfBlocks > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbRead ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN OUT UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbWrite ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +EFIAPI > > +FvbEraseBlocks ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + ... > > + ); > > + > > +typedef struct { > > + EFI_TPL OriginalTPL; > > +} NOR_FLASH_LOCK_CONTEXT; > > + > > +VOID > > +EFIAPI > > +NorFlashLock ( > > + NOR_FLASH_LOCK_CONTEXT *Context > > + ); > > + > > +VOID > > +EFIAPI > > +NorFlashUnlock ( > > + NOR_FLASH_LOCK_CONTEXT *Context > > + ); > > + > > +EFI_STATUS > > +NorFlashUnlockAndEraseSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN UINTN BlockAddress > > + ); > > + > > +EFI_STATUS > > +NorFlashWriteSingleBlock ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashWriteBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + IN VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashReadBlocks ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashRead ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN UINTN BufferSizeInBytes, > > + OUT VOID *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashWrite ( > > + IN NOR_FLASH_INSTANCE *Instance, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ); > > + > > +EFI_STATUS > > +NorFlashReset ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ); > > + > > +#endif /* __NOR_FLASH_H__ */ > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > new file mode 100644 > > index 0000000..6ad3769 > > --- /dev/null > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > @@ -0,0 +1,740 @@ > > +/*++ @file NorFlashFvb.c > > + > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > + > > + This program and the accompanying materials > > + are licensed and made available under the terms and conditions of the > > + BSD License which accompanies this distribution. The full text of the > > + license may be found at http://opensource.org/licenses/bsd-license.php > > + > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > + > > + --*/ > > + > > +#include <Guid/VariableFormat.h> > > +#include <Library/BaseMemoryLib.h> > > +#include <Library/BaseLib.h> > > +#include <Library/MemoryAllocationLib.h> > > +#include <Library/PcdLib.h> > > +#include <Library/UefiLib.h> > > + > > +#include "NorFlash.h" > > + > > +UINTN mFlashNvStorageVariableBase; > > + > > +/// > > +/// The Firmware Volume Block Protocol is the low-level interface > > +/// to a firmware volume. File-level access to a firmware volume > > +/// should not be done using the Firmware Volume Block Protocol. > > +/// Normal access to a firmware volume must use the Firmware > > +/// Volume Protocol. Typically, only the file system driver that > > +/// produces the Firmware Volume Protocol will bind to the > > +/// Firmware Volume Block Protocol. > > +/// > > + > > +/** > > + Initialises the FV Header and Variable Store Header > > + to support variable operations. > > + > > + @param[in] Ptr - Location to initialise the headers > > + > > +**/ > > +EFI_STATUS > > +InitializeFvAndVariableStoreHeaders ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + EFI_STATUS Status; > > + VOID* Headers; > > + UINTN HeadersLength; > > + EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader; > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > + > > + HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + > > + sizeof (VARIABLE_STORE_HEADER); > > + Headers = AllocateZeroPool (HeadersLength); > > + > > + // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND > > + // the FTW working area AND the FTW Spare contiguous. > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) + > > + PcdGet32 (PcdFlashNvStorageVariableSize) == > > + PcdGet32 (PcdFlashNvStorageFtwWorkingBase)); > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) + > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) == > > + PcdGet32 (PcdFlashNvStorageFtwSpareBase)); > > + > > + // Check if the size of the area is at least one block size > > + ASSERT ((PcdGet32 (PcdFlashNvStorageVariableSize) > 0) && > > + (PcdGet32 (PcdFlashNvStorageVariableSize) / Instance->BlockSize > 0)); > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwWorkingSize) > 0) && > > + (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) / Instance->BlockSize > 0)); > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwSpareSize) > 0) && > > + (PcdGet32 (PcdFlashNvStorageFtwSpareSize) / Instance->BlockSize > 0)); > > + > > + // Ensure the Variable area Base Addresses are aligned on a > > + // block size boundaries > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) % Instance->BlockSize == 0); > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) % Instance->BlockSize == 0); > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwSpareBase) % Instance->BlockSize == 0); > > + > > + // > > + // EFI_FIRMWARE_VOLUME_HEADER > > + // > > + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers; > > + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid); > > + FirmwareVolumeHeader->FvLength = > > + PcdGet32 (PcdFlashNvStorageVariableSize) + > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE; > > + FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) ( > > + EFI_FVB2_READ_ENABLED_CAP | > > + // Reads may be enabled > > + EFI_FVB2_READ_STATUS | > > + // Reads are currently enabled > > + EFI_FVB2_STICKY_WRITE | > > + // A block erase is required to flip > > + // bits into EFI_FVB2_ERASE_POLARITY > > + EFI_FVB2_MEMORY_MAPPED | > > + // It is memory mapped > > + EFI_FVB2_ERASE_POLARITY | > > + // After erasure all bits take this > > + // value (i.e. '1') > > + EFI_FVB2_WRITE_STATUS | > > + // Writes are currently enabled > > + EFI_FVB2_WRITE_ENABLED_CAP > > + // Writes may be enabled > > + ); > > + FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY); > > + FirmwareVolumeHeader->Revision = EFI_FVH_REVISION; > > + FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->LastBlock + 1; > > + FirmwareVolumeHeader->BlockMap[0].Length = Instance->BlockSize; > > + FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0; > > + FirmwareVolumeHeader->BlockMap[1].Length = 0; > > + FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ( > > + (UINT16*)FirmwareVolumeHeader, > > + FirmwareVolumeHeader->HeaderLength); > > + > > + // > > + // VARIABLE_STORE_HEADER > > + // > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)Headers + > > + FirmwareVolumeHeader->HeaderLength); > > + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid); > > + VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - > > + FirmwareVolumeHeader->HeaderLength; > > + VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED; > > + VariableStoreHeader->State = VARIABLE_STORE_HEALTHY; > > + > > + // Install the combined super-header in the NorFlash > > + Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers); > > + > > + FreePool (Headers); > > + return Status; > > +} > > + > > +/** > > + Check the integrity of firmware volume header. > > + > > + @param[in] FwVolHeader - A pointer to a firmware volume header > > + > > + @retval EFI_SUCCESS - The firmware volume is consistent > > + @retval EFI_NOT_FOUND - The firmware volume has been corrupted. > > + > > +**/ > > +EFI_STATUS > > +ValidateFvHeader ( > > + IN NOR_FLASH_INSTANCE *Instance > > + ) > > +{ > > + UINT16 Checksum; > > + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > + UINTN VariableStoreLength; > > + UINTN FvLength; > > + > > + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress; > > + > > + FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > + > > + // > > + // Verify the header revision, header signature, length > > + // Length of FvBlock cannot be 2**64-1 > > + // HeaderLength cannot be an odd number > > + // > > + if ( (FwVolHeader->Revision != EFI_FVH_REVISION) > > + || (FwVolHeader->Signature != EFI_FVH_SIGNATURE) > > + || (FwVolHeader->FvLength != FvLength) > > + ) > > + { > > + DEBUG ((DEBUG_INFO, "%a: No Firmware Volume header present\n", > > + __FUNCTION__)); > > + return EFI_NOT_FOUND; > > + } > > + > > + // Check the Firmware Volume Guid > > + if (CompareGuid (&FwVolHeader->FileSystemGuid, > > + &gEfiSystemNvDataFvGuid) == FALSE ) { > > + DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\n", > > + __FUNCTION__)); > > + return EFI_NOT_FOUND; > > + } > > + > > + // Verify the header checksum > > + Checksum = CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader->HeaderLength); > > + if (Checksum != 0) { > > + DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n", > > + __FUNCTION__, Checksum)); > > + return EFI_NOT_FOUND; > > + } > > + > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)FwVolHeader + > > + FwVolHeader->HeaderLength); > > + > > + // Check the Variable Store Guid > > + if (!CompareGuid (&VariableStoreHeader->Signature, > > + &gEfiVariableGuid) && > > + !CompareGuid (&VariableStoreHeader->Signature, > > + &gEfiAuthenticatedVariableGuid)) { > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Guid non-compatible\n", > > + __FUNCTION__)); > > + return EFI_NOT_FOUND; > > + } > > + > > + VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - > > + FwVolHeader->HeaderLength; > > + if (VariableStoreHeader->Size != VariableStoreLength) { > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Length does not match\n", > > + __FUNCTION__)); > > + return EFI_NOT_FOUND; > > + } > > + > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The GetAttributes() function retrieves the attributes and > > + current settings of the block. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and > > + current settings are returned. > > + Type EFI_FVB_ATTRIBUTES_2 is defined in > > + EFI_FIRMWARE_VOLUME_HEADER. > > + > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ) > > +{ > > + EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) ( > > + > > + EFI_FVB2_READ_ENABLED_CAP | > > + // Reads may be enabled > > + EFI_FVB2_READ_STATUS | > > + // Reads are currently enabled > > + EFI_FVB2_WRITE_ENABLED_CAP | > > + // Writes may be enabled > > + EFI_FVB2_WRITE_STATUS | > > + // Writes are currently enabled > > + EFI_FVB2_STICKY_WRITE | > > + // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY > > + EFI_FVB2_MEMORY_MAPPED | > > + // It is memory mapped > > + EFI_FVB2_ERASE_POLARITY > > + // After erasure all bits take this value (i.e. '1') > > + > > + ); > > + > > + *Attributes = FlashFvbAttributes; > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes)); > > + > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The SetAttributes() function sets configurable firmware volume attributes > > + and returns the new settings of the firmware volume. > > + > > + > > + @param This Indicates the > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Attributes On input, Attributes is a pointer to > > + EFI_FVB_ATTRIBUTES_2 that contains the desired > > + firmware volume settings. On successful return, > > + it contains the new settings of the firmware > > + volume. Type EFI_FVB_ATTRIBUTES_2 is defined > > + in EFI_FIRMWARE_VOLUME_HEADER. > > + > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > + > > + @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with > > + the capabilities > > + as declared in the firmware volume header. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbSetAttributes ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > + ) > > +{ > > + DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes)); > > + return EFI_UNSUPPORTED; > > +} > > + > > +/** > > + The GetPhysicalAddress() function retrieves the base address of > > + a memory-mapped firmware volume. This function should be called > > + only for memory-mapped firmware volumes. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > + instance. > > + > > + @param Address Pointer to a caller-allocated > > + EFI_PHYSICAL_ADDRESS that, on successful > > + return from GetPhysicalAddress(), contains the > > + base address of the firmware volume. > > + > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > + > > + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetPhysicalAddress ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + OUT EFI_PHYSICAL_ADDRESS *Address > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", > > + Instance->RegionBaseAddress)); > > + > > + ASSERT (Address != NULL); > > + > > + *Address = mFlashNvStorageVariableBase; > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + The GetBlockSize() function retrieves the size of the requested > > + block. It also returns the number of additional blocks with > > + the identical size. The GetBlockSize() function is used to > > + retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER). > > + > > + > > + @param This Indicates the > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > + > > + @param Lba Indicates the block for which to return > > + the size. > > + > > + @param BlockSize Pointer to a caller-allocated UINTN in which > > + the size of the block is returned. > > + > > + @param NumberOfBlocks Pointer to a caller-allocated UINTN in > > + which the number of consecutive blocks, > > + starting with Lba, is returned. All > > + blocks in this range have a size of > > + BlockSize. > > + > > + > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > + > > + @retval EFI_INVALID_PARAMETER The requested LBA is out of range. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbGetBlockSize ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + OUT UINTN *BlockSize, > > + OUT UINTN *NumberOfBlocks > > + ) > > +{ > > + EFI_STATUS Status; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", > > + Lba, Instance->BlockSize, Instance->LastBlock)); > > + > > + if (Lba > Instance->LastBlock) { > > + DEBUG ((DEBUG_ERROR, > > + "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", > > + Lba, Instance->LastBlock)); > > + Status = EFI_INVALID_PARAMETER; > > + } else { > > + // This is easy because in this platform each NorFlash device > > + // has equal sized blocks. > > + *BlockSize = (UINTN) Instance->BlockSize; > > + *NumberOfBlocks = (UINTN) (Instance->LastBlock - Lba + 1); > > + > > + DEBUG ((DEBUG_BLKIO, > > + "FvbGetBlockSize: *BlockSize=0x%x,*NumberOfBlocks=0x%x.\n", > > + *BlockSize, *NumberOfBlocks)); > > + > > + Status = EFI_SUCCESS; > > + } > > + > > + return Status; > > +} > > + > > +/** > > + Reads the specified number of bytes into a buffer from the specified block. > > + > > + The Read() function reads the requested number of bytes from the > > + requested block and stores them in the provided buffer. > > + Implementations should be mindful that the firmware volume > > + might be in the ReadDisabled state. If it is in this state, > > + the Read() function must return the status code > > + EFI_ACCESS_DENIED without modifying the contents of the > > + buffer. The Read() function must also prevent spanning block > > + boundaries. If a read is requested that would span a block > > + boundary, the read must read up to the boundary but not > > + beyond. The output parameter NumBytes must be set to correctly > > + indicate the number of bytes actually read. The caller must be > > + aware that a read may be partially completed. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > + instance. > > + > > + @param Lba The starting logical block index from which to read. > > + > > + @param Offset Offset into the block at which to begin reading. > > + > > + @param NumBytes Pointer to a UINTN. > > + At entry, *NumBytes contains the total size of the buffer. > > + At exit, *NumBytes contains the total number of bytes read. > > + > > + @param Buffer Pointer to a caller-allocated buffer that will be used > > + to hold the data that is read. > > + > > + @retval EFI_SUCCESS The firmware volume was read successfully,and contents are > > + in Buffer. > > + > > + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary. > > + On output, NumBytes contains the total number of bytes > > + returned in Buffer. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and > > + could not be read. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbRead ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN OUT UINT8 *Buffer > > + ) > > +{ > > + EFI_STATUS TempStatus; > > + UINTN BlockSize; > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, > > + "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > + Instance->StartLba + Lba, Offset, *NumBytes, Buffer)); > > + > > + TempStatus = EFI_SUCCESS; > > + > > + // Cache the block size to avoid de-referencing pointers all the time > > + BlockSize = Instance->BlockSize; > > + > > + DEBUG ((DEBUG_BLKIO, > > + "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", > > + Offset, *NumBytes, BlockSize )); > > + > > + // The read must not span block boundaries. > > + // We need to check each variable individually because adding two > > + // large values together overflows. > > + if ((Offset >= BlockSize) || > > + (*NumBytes > BlockSize) || > > + ((Offset + *NumBytes) > BlockSize)) { > > + DEBUG ((DEBUG_ERROR, > > + "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > + Offset, *NumBytes, BlockSize )); > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // We must have some bytes to read > > + if (*NumBytes == 0) { > > + return EFI_BAD_BUFFER_SIZE; > > + } > > + > > + // Decide if we are doing full block reads or not. > > + if (*NumBytes % BlockSize != 0) { > > + TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer); > > + if (EFI_ERROR (TempStatus)) { > > + return EFI_DEVICE_ERROR; > > + } > > + } else { > > + // Read NOR Flash data into shadow buffer > > + TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer); > > + if (EFI_ERROR (TempStatus)) { > > + // Return one of the pre-approved error statuses > > + return EFI_DEVICE_ERROR; > > + } > > + } > > + return EFI_SUCCESS; > > +} > > + > > +/** > > + Writes the specified number of bytes from the input buffer to the block. > > + > > + The Write() function writes the specified number of bytes from > > + the provided buffer to the specified block and offset. If the > > + firmware volume is sticky write, the caller must ensure that > > + all the bits of the specified range to write are in the > > + EFI_FVB_ERASE_POLARITY state before calling the Write() > > + function, or else the result will be unpredictable. This > > + unpredictability arises because, for a sticky-write firmware > > + volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY > > + state but cannot flip it back again. Before calling the > > + Write() function, it is recommended for the caller to first call > > + the EraseBlocks() function to erase the specified block to > > + write. A block erase cycle will transition bits from the > > + (NOT)EFI_FVB_ERASE_POLARITY state back to the > > + EFI_FVB_ERASE_POLARITY state. Implementations should be > > + mindful that the firmware volume might be in the WriteDisabled > > + state. If it is in this state, the Write() function must > > + return the status code EFI_ACCESS_DENIED without modifying the > > + contents of the firmware volume. The Write() function must > > + also prevent spanning block boundaries. If a write is > > + requested that spans a block boundary, the write must store up > > + to the boundary but not beyond. The output parameter NumBytes > > + must be set to correctly indicate the number of bytes actually > > + written. The caller must be aware that a write may be > > + partially completed. All writes, partial or otherwise, must be > > + fully flushed to the hardware before the Write() service > > + returns. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > + instance. > > + > > + @param Lba The starting logical block index to write to. > > + > > + @param Offset Offset into the block at which to begin writing. > > + > > + @param NumBytes The pointer to a UINTN. > > + At entry, *NumBytes contains the total size of the > > + buffer. > > + At exit, *NumBytes contains the total number of > > + bytes actually written. > > + > > + @param Buffer The pointer to a caller-allocated buffer that contains > > + the source for the write. > > + > > + @retval EFI_SUCCESS The firmware volume was written successfully. > > + > > + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary. > > + On output, NumBytes contains the total number of bytes > > + actually written. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not > > + be written. > > + > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbWrite ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + IN EFI_LBA Lba, > > + IN UINTN Offset, > > + IN OUT UINTN *NumBytes, > > + IN UINT8 *Buffer > > + ) > > +{ > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer); > > +} > > + > > +/** > > + Erases and initialises a firmware volume block. > > + > > + The EraseBlocks() function erases one or more blocks as denoted > > + by the variable argument list. The entire parameter list of > > + blocks must be verified before erasing any blocks. If a block is > > + requested that does not exist within the associated firmware > > + volume (it has a larger index than the last block of the > > + firmware volume), the EraseBlocks() function must return the > > + status code EFI_INVALID_PARAMETER without modifying the contents > > + of the firmware volume. Implementations should be mindful that > > + the firmware volume might be in the WriteDisabled state. If it > > + is in this state, the EraseBlocks() function must return the > > + status code EFI_ACCESS_DENIED without modifying the contents of > > + the firmware volume. All calls to EraseBlocks() must be fully > > + flushed to the hardware before the EraseBlocks() service > > + returns. > > + > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > + instance. > > + > > + @param ... The variable argument list is a list of tuples. > > + Each tuple describes a range of LBAs to erase > > + and consists of the following: > > + - An EFI_LBA that indicates the starting LBA > > + - A UINTN that indicates the number of blocks > > + to erase. > > + > > + The list is terminated with an > > + EFI_LBA_LIST_TERMINATOR. > > + For example, the following indicates that two > > + ranges of blocks (5-7 and 10-11) are to be erased: > > + EraseBlocks (This, 5, 3, 10, 2, > > + EFI_LBA_LIST_TERMINATOR); > > + > > + @retval EFI_SUCCESS The erase request successfully completed. > > + > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > + > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly > > + and could not be written. > > + The firmware device may have been partially erased. > > + > > + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable > > + argument list do not exist in the firmware volume. > > + > > + **/ > > +EFI_STATUS > > +EFIAPI > > +FvbEraseBlocks ( > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > + ... > > + ) > > +{ > > + EFI_STATUS Status; > > + VA_LIST Args; > > + UINTN BlockAddress; // Physical address of Lba to erase > > + EFI_LBA StartingLba; // Lba from which we start erasing > > + UINTN NumOfLba; // Number of Lba blocks to erase > > + NOR_FLASH_INSTANCE *Instance; > > + > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > + > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n")); > > + > > + Status = EFI_SUCCESS; > > + > > + // Before erasing, check the entire list of parameters to > > + // ensure all specified blocks are valid > > + > > + VA_START (Args, This); > > + do { > > + // Get the Lba from which we start erasing > > + StartingLba = VA_ARG (Args, EFI_LBA); > > + > > + // Have we reached the end of the list? > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > + //Exit the while loop > > + break; > > + } > > + > > + // How many Lba blocks are we requested to erase? > > + NumOfLba = VA_ARG (Args, UINTN); > > + > > + // All blocks must be within range > > + DEBUG (( > > + DEBUG_BLKIO, > > + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n", > > + Instance->StartLba + StartingLba, > > + (UINT64)NumOfLba, > > + Instance->LastBlock > > + )); > > + if ((NumOfLba == 0) || > > + ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->LastBlock)) { > > + VA_END (Args); > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n")); > > + Status = EFI_INVALID_PARAMETER; > > + goto EXIT; > > + } > > + } while (TRUE); > > + VA_END (Args); > > + > > + // > > + // To get here, all must be ok, so start erasing > > + // > > + VA_START (Args, This); > > + do { > > + // Get the Lba from which we start erasing > > + StartingLba = VA_ARG (Args, EFI_LBA); > > + > > + // Have we reached the end of the list? > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > + // Exit the while loop > > + break; > > + } > > + > > + // How many Lba blocks are we requested to erase? > > + NumOfLba = VA_ARG (Args, UINTN); > > + > > + // Go through each one and erase it > > + while (NumOfLba > 0) { > > + > > + // Get the physical address of Lba to erase > > + BlockAddress = GET_NOR_BLOCK_ADDRESS ( > > + Instance->RegionBaseAddress, > > + Instance->StartLba + StartingLba, > > + Instance->BlockSize > > + ); > > + > > + // Erase it > > + DEBUG ((DEBUG_BLKIO, > > + "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", > > + Instance->StartLba + StartingLba, BlockAddress)); > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > + if (EFI_ERROR (Status)) { > > + VA_END (Args); > > + Status = EFI_DEVICE_ERROR; > > + goto EXIT; > > + } > > + > > + // Move to the next Lba > > + StartingLba++; > > + NumOfLba--; > > + } > > + } while (TRUE); > > + VA_END (Args); > > + > > +EXIT: > > + return Status; > > +} > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > new file mode 100644 > > index 0000000..08e20ae > > --- /dev/null > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > @@ -0,0 +1,250 @@ > > +/*++ @file NorFlashStandaloneMm.c > > + > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > + > > + This program and the accompanying materials > > + are licensed and made available under the terms and conditions of the BSD > > + License which accompanies this distribution. The full text of the license > > + may be found at http://opensource.org/licenses/bsd-license.php > > + > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > + > > + --*/ > > + > > +#include <PiMm.h> > > + > > +#include <Library/BaseLib.h> > > +#include <Library/BaseMemoryLib.h> > > +#include <Library/MemoryAllocationLib.h> > > +#include <Library/PcdLib.h> > > + > > +#include "NorFlash.h" > > + > > +// > > +// Global variable declarations > > +// > > +STATIC NOR_FLASH_INSTANCE **mNorFlashInstances; > > +STATIC UINT32 mNorFlashDeviceCount; > > + > > +STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = { > > + NOR_FLASH_SIGNATURE, // Signature > > + NULL, // Handle ... NEED TO BE FILLED > > + > > + 0, // DeviceBaseAddress ... NEED TO BE FILLED > > + 0, // RegionBaseAddress ... NEED TO BE FILLED > > + 0, // Size ... NEED TO BE FILLED > > + 0, // BlockSize ... NEED TO BE FILLED > > + 0, // LastBlock ... NEED TO BE FILLED > > + 0, // StartLba ... NEED TO BE FILLED > > + > > + { > > + FvbGetAttributes, // GetAttributes > > + FvbSetAttributes, // SetAttributes > > + FvbGetPhysicalAddress, // GetPhysicalAddress > > + FvbGetBlockSize, // GetBlockSize > > + FvbRead, // Read > > + FvbWrite, // Write > > + FvbEraseBlocks, // EraseBlocks > > + NULL, //ParentHandle > > + }, // FvbProtoccol; > > + NULL, // ShadowBuffer > > + { > > + { > > + { > > + HARDWARE_DEVICE_PATH, > > + HW_VENDOR_DP, > > + { > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)), > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8) > > + } > > + }, > > + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, > > + // GUID ... NEED TO BE FILLED > > + }, > > + 0, // Index > > + { > > + END_DEVICE_PATH_TYPE, > > + END_ENTIRE_DEVICE_PATH_SUBTYPE, > > + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } > > + } > > + } // DevicePath > > +}; > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashFvbInitialize ( > > + IN NOR_FLASH_INSTANCE* Instance > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 FvbNumLba; > > + > > + DEBUG ((DEBUG_BLKIO,"NorFlashFvbInitialize\n")); > > + ASSERT ((Instance != NULL)); > > + > > + mFlashNvStorageVariableBase = FixedPcdGet32 (PcdFlashNvStorageVariableBase); > > + > > + // Set the index of the first LBA for the FVB > > + Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - > > + Instance->RegionBaseAddress) / Instance->BlockSize; > > + > > + // Determine if there is a valid header at the beginning of the NorFlash > > + Status = ValidateFvHeader (Instance); > > + > > + // Install the Default FVB header if required > > + if (EFI_ERROR (Status)) { > > + // There is no valid header, so time to install one. > > + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__)); > > + DEBUG ((DEBUG_INFO, "%a: Installing a correct one for this volume.\n", > > + __FUNCTION__)); > > + > > + // Erase all the NorFlash that is reserved for variable storage > > + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / > > + Instance->BlockSize; > > + > > + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, > > + EFI_LBA_LIST_TERMINATOR); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + > > + // Install all appropriate headers > > + Status = InitializeFvAndVariableStoreHeaders (Instance); > > + if (EFI_ERROR (Status)) { > > + return Status; > > + } > > + } > > + > > + return Status; > > +} > > + > > +VOID > > +EFIAPI > > +NorFlashLock ( > > + NOR_FLASH_LOCK_CONTEXT *Context > > + ) > > +{ > > +} > > + > > +VOID > > +EFIAPI > > +NorFlashUnlock ( > > + NOR_FLASH_LOCK_CONTEXT *Context > > + ) > > +{ > > +} > > + > > +EFI_STATUS > > +NorFlashCreateInstance ( > > + IN UINTN NorFlashDeviceBase, > > + IN UINTN NorFlashRegionBase, > > + IN UINTN NorFlashSize, > > + IN UINT32 Index, > > + IN UINT32 BlockSize, > > + IN BOOLEAN SupportFvb, > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > + ) > > +{ > > + EFI_STATUS Status; > > + NOR_FLASH_INSTANCE* Instance; > > + > > + ASSERT (NorFlashInstance != NULL); > > + > > + Instance = AllocateCopyPool (sizeof (NOR_FLASH_INSTANCE), > > + &mNorFlashInstanceTemplate); > > + if (Instance == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + Instance->DeviceBaseAddress = NorFlashDeviceBase; > > + Instance->RegionBaseAddress = NorFlashRegionBase; > > + Instance->Size = NorFlashSize; > > + > > + Instance->BlockSize = BlockSize; > > + Instance->LastBlock = (NorFlashSize / BlockSize)-1; > > + > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid); > > + Instance->DevicePath.Index = (UINT8)Index; > > + > > + NorFlashReset (Instance); > > + > > + Instance->ShadowBuffer = AllocatePool (BlockSize);; > > + if (Instance->ShadowBuffer == NULL) { > > + return EFI_OUT_OF_RESOURCES; > > + } > > + > > + if (SupportFvb) { > > + NorFlashFvbInitialize (Instance); > > + > > + //Install FirmwareVolumeBlock Protocol > > + Status = gMmst->MmInstallProtocolInterface ( > > + &Instance->Handle, > > + &gEfiSmmFirmwareVolumeBlockProtocolGuid, > > + EFI_NATIVE_INTERFACE, > > + &Instance->FvbProtocol > > + ); > > + if (EFI_ERROR (Status)) { > > + FreePool (Instance); > > + return Status; > > + } > > + } > > + > > + *NorFlashInstance = Instance; > > + return Status; > > +} > > + > > +EFI_STATUS > > +EFIAPI > > +NorFlashInitialise ( > > + IN EFI_HANDLE ImageHandle, > > + IN EFI_MM_SYSTEM_TABLE *SystemTable > > + ) > > +{ > > + EFI_STATUS Status; > > + UINT32 Index; > > + NOR_FLASH_DESCRIPTION* NorFlashDevices; > > + BOOLEAN ContainVariableStorage; > > + > > + Status = NorFlashPlatformInitialization (); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashInitialise: Fail to initialize Nor Flash devices\n")); > > + return Status; > > + } > > + > > + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n")); > > + return Status; > > + } > > + > > + mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE*) * mNorFlashDeviceCount); > > + > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > + // Check if this NOR Flash device contain the variable storage region > > + ContainVariableStorage = > > + (NorFlashDevices[Index].RegionBaseAddress <= > > + PcdGet32 (PcdFlashNvStorageVariableBase)) && > > + (PcdGet32 (PcdFlashNvStorageVariableBase) + > > + PcdGet32 (PcdFlashNvStorageVariableSize) <= > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > + > > + Status = NorFlashCreateInstance ( > > + NorFlashDevices[Index].DeviceBaseAddress, > > + NorFlashDevices[Index].RegionBaseAddress, > > + NorFlashDevices[Index].Size, > > + Index, > > + NorFlashDevices[Index].BlockSize, > > + ContainVariableStorage, > > + &mNorFlashInstances[Index] > > + ); > > + if (EFI_ERROR (Status)) { > > + DEBUG ((DEBUG_ERROR, > > + "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index)); > > + } > > + } > > + return Status; > > +} > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > new file mode 100644 > > index 0000000..12073fc > > --- /dev/null > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > @@ -0,0 +1,68 @@ > > +#/** @file > > +# > > +# Component description file for NorFlashStandaloneMm module > > +# > > +# Copyright (c) 2019, ARM Ltd. All rights reserved.<BR> > > +# > > +# This program and the accompanying materials > > +# are licensed and made available under the terms and conditions of the BSD License > > +# which accompanies this distribution. The full text of the license may be found at > > +# http://opensource.org/licenses/bsd-license.php > > +# > > +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > +# > > +#**/ > > + > > +[Defines] > > + INF_VERSION = 0x00010005 > > + BASE_NAME = StandaloneMmNorFlash > > + FILE_GUID = 166F677B-DAC9-4AE4-AD34-2FF2504B0637 > > + MODULE_TYPE = MM_STANDALONE > > + VERSION_STRING = 1.0 > > + PI_SPECIFICATION_VERSION = 0x00010032 > > + ENTRY_POINT = NorFlashInitialise > > + > > +[Sources.common] > > + NorFlash.c > > + NorFlashFvb.c > > + NorFlashStandaloneMm.c > > + > > +[Packages] > > + ArmPkg/ArmPkg.dec > > + ArmPlatformPkg/ArmPlatformPkg.dec > > + MdePkg/MdePkg.dec > > + MdeModulePkg/MdeModulePkg.dec > > + StandaloneMmPkg/StandaloneMmPkg.dec > > + > > +[LibraryClasses] > > + ArmLib > > + ArmSvcLib > > + BaseMemoryLib > > + BaseLib > > + DebugLib > > + MemoryAllocationLib > > + MmServicesTableLib > > + NorFlashPlatformLib > > + StandaloneMmDriverEntryPoint > > + > > +[Guids] > > + gEfiSystemNvDataFvGuid > > + gEfiVariableGuid > > + gEfiAuthenticatedVariableGuid > > + > > +[Protocols] > > + gEfiSmmFirmwareVolumeBlockProtocolGuid > > + > > +[Pcd.common] > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize > > + > > + gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked > > + > > +[Depex] > > + TRUE > > -- > > 2.7.4 > > > > _______________________________________________ > > edk2-devel mailing list > > edk2-devel@lists.01.org > > https://lists.01.org/mailman/listinfo/edk2-devel ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-24 9:05 ` [edk2] " jagadeesh.ujja @ 2019-04-24 13:06 ` Ard Biesheuvel 2019-04-29 5:59 ` Jagadeesh Ujja 0 siblings, 1 reply; 10+ messages in thread From: Ard Biesheuvel @ 2019-04-24 13:06 UTC (permalink / raw) To: edk2-devel-groups-io, Jagadeesh Ujja; +Cc: Leif Lindholm On Wed, 24 Apr 2019 at 11:05, Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > Fwd to new EDKII development mailing list. > > hi Ard, > > Sorry about missing your previous comment and adding here. > > "Hello Jagadeesh, > > Why are you moving this driver into edk2-platforms? I'd prefer to have > > it alongside the non-MM version instead. > > That would allow us to share a lot more code between the two versions." > ----------------- > > my Point of view: > > In ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and > disk I/O protocols. > In case of StandaloneMM norflash driver the block I/O and disk I/O > protocols are not required > > We don’t want to remove support of block I/O and disk I/O protocols in > “ArmPlatformPkg/Drivers/NorFlashDxe” > In this case “NOR_FLASH_INSTANCE” is different in both > drivers(DXE/STANDALONEMM). So we end up with having 2 different > drivers. > > Even if we want to share common code then we end up with multiple > files as “NOR_FLASH_INSTANCE” is used in almost all files > Ex: “NorFlash.c” “NorFlash.h” NorFlashFvb.c > In this case “NorFlash.c” will have 2 copies one used by DXE and > other by STANDALONE_MM driver > > So instead of having 2 different drivers in one place > “ArmPlatformPkg/Drivers/NorFlashDxe” > added a new refactored nor flash driver in "Platform/ARM/Drivers" > > I am not sure if any other platform is using > “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and > disk I/O protocols > if we remove “support of block I/O and disk I/O protocols” then we > can share the common code easily. > I see your point. The only reason you need block i/o and disk i/o is to use ordinary partition and filesystem drivers. I guess Juno uses this for its magic filesystem? If not, I'd be glad to get rid of it. > > On Mon, Apr 8, 2019 at 7:16 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > hi Ard/Leif > > > > Please let me know if you have any comments on this patch set > > thanks > > Jagadeesh > > > > On Tue, Apr 2, 2019 at 6:48 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > > > Refactor the existing ArmPlatformPkg NOR flash driver to be usable > > > as a StandaloneMM library. Some of the functionality not required > > > in StandaloneMM, such as the block layer, is removed. This allows > > > storing of EFI variables on NOR flash which is accessible only via > > > the MM STANDALONE mode software > > > > > > Contributed-under: TianoCore Contribution Agreement 1.1 > > > Signed-off-by: Jagadeesh Ujja <jagadeesh.ujja@arm.com> > > > --- > > > Changes since v1: > > > - This is a next version of patch > > > “[edk2] [PATCH 0/2] Allow use of ArmPlatformPkg NOR flash driver in StandaloneMM” > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036882.html > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036884.html > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036883.html > > > - ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and disk > > > I/O protocols. This driver is required in StandaloneMM but the block I/O > > > and disk I/O protocols are not required in StandaloneMM. > > > - Instead of removing support for block I/O and disk I/O protocols, > > > add a new refactored nor flash driver in "Platform/ARM/Drivers" > > > - Addressed all the comments from Ard Biesheuvel. > > > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c | 982 ++++++++++++++++++++ > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h | 326 +++++++ > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c | 740 +++++++++++++++ > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c | 250 +++++ > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf | 68 ++ > > > 5 files changed, 2366 insertions(+) > > > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > > new file mode 100644 > > > index 0000000..4ba4fb5 > > > --- /dev/null > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > > @@ -0,0 +1,982 @@ > > > +/** @file NorFlash.c > > > + > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > + > > > + This program and the accompanying materials > > > + are licensed and made available under the terms and conditions of the > > > + BSD License which accompanies this distribution. The full text of the > > > + license may be found at http://opensource.org/licenses/bsd-license.php > > > + > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > + > > > +**/ > > > + > > > +#include <Library/BaseMemoryLib.h> > > > +#include <Library/MemoryAllocationLib.h> > > > +#include <Library/PcdLib.h> > > > +#include <Library/UefiLib.h> > > > + > > > +#include "NorFlash.h" > > > + > > > +STATIC > > > +UINT32 > > > +NorFlashReadStatusRegister ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN SR_Address > > > + ) > > > +{ > > > + // Prepare to read the status register > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER); > > > + return MmioRead32 (Instance->DeviceBaseAddress); > > > +} > > > + > > > +STATIC > > > +BOOLEAN > > > +NorFlashBlockIsLocked ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ) > > > +{ > > > + UINT32 LockStatus; > > > + > > > + // Send command for reading device id > > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > > + > > > + // Read block lock status > > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > > + > > > + // Decode block lock status > > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > > + > > > + if ((LockStatus & 0x2) != 0) { > > > + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n")); > > > + } > > > + > > > + return ((LockStatus & 0x1) != 0); > > > +} > > > + > > > +STATIC > > > +EFI_STATUS > > > +NorFlashUnlockSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ) > > > +{ > > > + UINT32 LockStatus; > > > + > > > + // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations > > > + // and to protect shared data structures. > > > + > > > + if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) { > > > + do { > > > + // Request a lock setup > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > > + > > > + // Request an unlock > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > > + > > > + // Send command for reading device id > > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > > + > > > + // Read block lock status > > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > > + > > > + // Decode block lock status > > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > > + } while ((LockStatus & 0x1) == 1); > > > + } else { > > > + // Request a lock setup > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > > + > > > + // Request an unlock > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > > + > > > + // Wait until the status register gives us the all clear > > > + do { > > > + LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress); > > > + } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > + } > > > + > > > + // Put device back into Read Array mode > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress)); > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +STATIC > > > +EFI_STATUS > > > +NorFlashUnlockSingleBlockIfNecessary ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) { > > > + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress); > > > + } > > > + > > > + return Status; > > > +} > > > + > > > +/** > > > + * The following function presumes that the block has already been unlocked. > > > + **/ > > > +STATIC > > > +EFI_STATUS > > > +NorFlashEraseSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINT32 StatusRegister; > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + // Request a block erase and then confirm it > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP); > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM); > > > + > > > + // Wait until the status register gives us the all clear > > > + do { > > > + StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress); > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > + > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > + DEBUG ((DEBUG_ERROR, > > > + "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == > > > + (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", > > > + BlockAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_ERASE) { > > > + DEBUG ((DEBUG_ERROR, > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", > > > + BlockAddress, StatusRegister)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > + // The debug level message has been reduced because a device > > > + // lock might happen. In this case we just retry it ... > > > + DEBUG ((DEBUG_INFO, > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", > > > + BlockAddress)); > > > + Status = EFI_WRITE_PROTECTED; > > > + } > > > + > > > + if (EFI_ERROR (Status)) { > > > + // Clear the Status Register > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > + } > > > + > > > + // Put device back into Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + return Status; > > > +} > > > + > > > +/** > > > + * This function unlock and erase an entire NOR Flash block. > > > + **/ > > > +EFI_STATUS > > > +NorFlashUnlockAndEraseSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINTN Index; > > > + NOR_FLASH_LOCK_CONTEXT Lock; > > > + > > > + NorFlashLock (&Lock); > > > + > > > + Index = 0; > > > + // The block erase might fail a first time (SW bug ?). Retry it ... > > > + do { > > > + // Unlock the block if we have to > > > + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > > + if (EFI_ERROR (Status)) { > > > + break; > > > + } > > > + Status = NorFlashEraseSingleBlock (Instance, BlockAddress); > > > + Index++; > > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED)); > > > + > > > + if (Index == NOR_FLASH_ERASE_RETRY) { > > > + DEBUG ((DEBUG_ERROR, > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", > > > + BlockAddress,Index)); > > > + } > > > + > > > + NorFlashUnlock (&Lock); > > > + > > > + return Status; > > > +} > > > + > > > +STATIC > > > +EFI_STATUS > > > +NorFlashWriteSingleWord ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN WordAddress, > > > + IN UINT32 WriteData > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINT32 StatusRegister; > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + // Request a write single word command > > > + SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP); > > > + > > > + // Store the word into NOR Flash; > > > + MmioWrite32 (WordAddress, WriteData); > > > + > > > + // Wait for the write to complete and then check for any errors; > > > + // i.e. check the Status Register > > > + do { > > > + // Prepare to read the status register > > > + StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress); > > > + // The chip is busy while the WRITE bit is not asserted > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > + > > > + > > > + // Perform a full status check: > > > + // Mask the relevant bits of Status Register. > > > + // Everything should be zero, if not, we have a problem > > > + > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", > > > + WordAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", > > > + WordAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", > > > + WordAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (!EFI_ERROR (Status)) { > > > + // Clear the Status Register > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, > > > + 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > + } > > > + > > > + // Put device back into Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + return Status; > > > +} > > > + > > > +/* > > > + * Writes data to the NOR Flash using the Buffered Programming method. > > > + * > > > + * The maximum size of the on-chip buffer is 32-words, because of hardware > > > + * restrictions. Therefore this function will only handle buffers up to 32 > > > + * words or 128 bytes. To deal with larger buffers, call this function again. > > > + * > > > + * This function presumes that both the TargetAddress and the > > > + * TargetAddress+BufferSize exist entirely within the NOR Flash. > > > + * Therefore these conditions will not be checked here. > > > + * > > > + * In buffered programming, if the target address not at the beginning of a > > > + * 32-bit word boundary,then programming time is doubled and power consumption > > > + * is increased. Therefore, it is a requirement to align buffer writes to > > > + * 32-bit word boundaries. > > > + * i.e. the last 4 bits of the target start address must be zero: 0x......00 > > > + */ > > > +EFI_STATUS > > > +NorFlashWriteBuffer ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN TargetAddress, > > > + IN UINTN BufferSizeInBytes, > > > + IN UINT32 *Buffer > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINTN BufferSizeInWords; > > > + UINTN Count; > > > + volatile UINT32 *Data; > > > + UINTN WaitForBuffer; > > > + BOOLEAN BufferAvailable; > > > + UINT32 StatusRegister; > > > + > > > + WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS; > > > + BufferAvailable = FALSE; > > > + > > > + // Check that the target address does not cross a 32-word boundary. > > > + if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) { > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // Check there are some data to program > > > + if (BufferSizeInBytes == 0) { > > > + return EFI_BUFFER_TOO_SMALL; > > > + } > > > + > > > + // Check that the buffer size does not exceed the maximum hardware buffer > > > + // size on chip. > > > + if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // Check that the buffer size is a multiple of 32-bit words > > > + if ((BufferSizeInBytes % 4) != 0) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // Pre-programming conditions checked, now start the algorithm. > > > + > > > + // Prepare the data destination address > > > + Data = (UINT32 *)TargetAddress; > > > + > > > + // Check the availability of the buffer > > > + do { > > > + // Issue the Buffered Program Setup command > > > + SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP); > > > + > > > + // Read back the status register bit#7 from the same address > > > + if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) { > > > + BufferAvailable = TRUE; > > > + } > > > + > > > + // Update the loop counter > > > + WaitForBuffer--; > > > + > > > + } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE)); > > > + > > > + // The buffer was not available for writing > > > + if (WaitForBuffer == 0) { > > > + Status = EFI_DEVICE_ERROR; > > > + goto EXIT; > > > + } > > > + > > > + // From now on we work in 32-bit words > > > + BufferSizeInWords = BufferSizeInBytes / (UINTN)4; > > > + > > > + // Write the word count, which is (buffer_size_in_words - 1), > > > + // because word count 0 means one word. > > > + SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1)); > > > + > > > + // Write the data to the NOR Flash, advancing each address by 4 bytes > > > + for (Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) { > > > + MmioWrite32 ((UINTN)Data, *Buffer); > > > + } > > > + > > > + // Issue the Buffered Program Confirm command, to start the programming operation > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM); > > > + > > > + // Wait for the write to complete and then check for any errors; > > > + // i.e. check the Status Register > > > + do { > > > + StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress); > > > + // The chip is busy while the WRITE bit is not asserted > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > + > > > + > > > + // Perform a full status check: > > > + // Mask the relevant bits of Status Register. > > > + // Everything should be zero, if not, we have a problem > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): VPP Range Error\n", > > > + TargetAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Program Error\n", > > > + TargetAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Device Protect Error\n", > > > + TargetAddress)); > > > + Status = EFI_DEVICE_ERROR; > > > + } > > > + > > > + if (!EFI_ERROR (Status)) { > > > + // Clear the Status Register > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > + } > > > + > > > +EXIT: > > > + // Put device back into Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + return Status; > > > +} > > > + > > > +STATIC > > > +EFI_STATUS > > > +NorFlashWriteFullBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINT32 *DataBuffer, > > > + IN UINT32 BlockSizeInWords > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINTN WordAddress; > > > + UINT32 WordIndex; > > > + UINTN BufferIndex; > > > + UINTN BlockAddress; > > > + UINTN BuffersInBlock; > > > + UINTN RemainingWords; > > > + UINTN Cnt; > > > + NOR_FLASH_LOCK_CONTEXT Lock; > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + // Get the physical address of the block > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4); > > > + > > > + // Start writing from the first address at the start of the block > > > + WordAddress = BlockAddress; > > > + > > > + NorFlashLock (&Lock); > > > + > > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > > + if (EFI_ERROR (Status)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", > > > + BlockAddress)); > > > + goto EXIT; > > > + } > > > + > > > + // To speed up the programming operation, NOR Flash is programmed using the > > > + // Buffered Programming method. > > > + > > > + // Check that the address starts at a 32-word boundary, > > > + // i.e. last 7 bits must be zero > > > + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) { > > > + > > > + // First, break the entire block into buffer-sized chunks. > > > + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES; > > > + > > > + // Then feed each buffer chunk to the NOR Flash > > > + // If a buffer does not contain any data, don't write it. > > > + for (BufferIndex=0; > > > + BufferIndex < BuffersInBlock; > > > + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, > > > + DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS > > > + ) { > > > + // Check the buffer to see if it contains any data (not set all 1s). > > > + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) { > > > + if (~DataBuffer[Cnt] != 0 ) { > > > + // Some data found, write the buffer. > > > + Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, > > > + DataBuffer); > > > + if (EFI_ERROR (Status)) { > > > + goto EXIT; > > > + } > > > + break; > > > + } > > > + } > > > + } > > > + > > > + // Finally, finish off any remaining words that are less than the > > > + // maximum size of the buffer > > > + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS; > > > + > > > + if (RemainingWords != 0) { > > > + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer); > > > + if (EFI_ERROR (Status)) { > > > + goto EXIT; > > > + } > > > + } > > > + > > > + } else { > > > + // For now, use the single word programming algorithm > > > + // It is unlikely that the NOR Flash will exist in an address which falls > > > + // within a 32 word boundary range, > > > + // i.e. which ends in the range 0x......01 - 0x......7F. > > > + for (WordIndex=0; > > > + WordIndex<BlockSizeInWords; > > > + WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) { > > > + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer); > > > + if (EFI_ERROR (Status)) { > > > + goto EXIT; > > > + } > > > + } > > > + } > > > + > > > +EXIT: > > > + NorFlashUnlock (&Lock); > > > + > > > + if (EFI_ERROR (Status)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", > > > + WordAddress, Status)); > > > + } > > > + return Status; > > > +} > > > + > > > +EFI_STATUS > > > +NorFlashWriteBlocks ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN BufferSizeInBytes, > > > + IN VOID *Buffer > > > + ) > > > +{ > > > + UINT32 *pWriteBuffer; > > > + EFI_STATUS Status = EFI_SUCCESS; > > > + EFI_LBA CurrentBlock; > > > + UINT32 BlockSizeInWords; > > > + UINT32 NumBlocks; > > > + UINT32 BlockCount; > > > + > > > + // The buffer must be valid > > > + if (Buffer == NULL) { > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // We must have some bytes to read > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes)); > > > + if (BufferSizeInBytes == 0) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // The size of the buffer must be a multiple of the block size > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->BlockSize)); > > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // All blocks must be within the device > > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", > > > + NumBlocks, Instance->LastBlock, Lba)); > > > + > > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n")); > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + BlockSizeInWords = Instance->BlockSize / 4; > > > + > > > + // Because the target *Buffer is a pointer to VOID, we must put all the > > > + // data into a pointer to a proper data type, so use *ReadBuffer > > > + pWriteBuffer = (UINT32 *)Buffer; > > > + > > > + CurrentBlock = Lba; > > > + for (BlockCount=0; > > > + BlockCount < NumBlocks; > > > + BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) { > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock)); > > > + > > > + Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords); > > > + > > > + if (EFI_ERROR (Status)) { > > > + break; > > > + } > > > + } > > > + > > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status)); > > > + return Status; > > > +} > > > + > > > +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0) > > > + > > > +/** > > > + Copy Length bytes from Source to Destination, using aligned accesses only. > > > + Note that this implementation uses memcpy() semantics rather then memmove() > > > + semantics, i.e., SourceBuffer and DestinationBuffer should not overlap. > > > + > > > + @param DestinationBuffer The target of the copy request. > > > + @param SourceBuffer The place to copy from. > > > + @param Length The number of bytes to copy. > > > + > > > + @return Destination > > > + > > > +**/ > > > +STATIC > > > +VOID * > > > +AlignedCopyMem ( > > > + OUT VOID *DestinationBuffer, > > > + IN CONST VOID *SourceBuffer, > > > + IN UINTN Length > > > + ) > > > +{ > > > + UINT8 *Destination8; > > > + CONST UINT8 *Source8; > > > + UINT32 *Destination32; > > > + CONST UINT32 *Source32; > > > + UINT64 *Destination64; > > > + CONST UINT64 *Source64; > > > + > > > + if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && Length >= 8) { > > > + Destination64 = DestinationBuffer; > > > + Source64 = SourceBuffer; > > > + while (Length >= 8) { > > > + *Destination64++ = *Source64++; > > > + Length -= 8; > > > + } > > > + > > > + Destination8 = (UINT8 *)Destination64; > > > + Source8 = (CONST UINT8 *)Source64; > > > + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && Length >= 4) { > > > + Destination32 = DestinationBuffer; > > > + Source32 = SourceBuffer; > > > + while (Length >= 4) { > > > + *Destination32++ = *Source32++; > > > + Length -= 4; > > > + } > > > + > > > + Destination8 = (UINT8 *)Destination32; > > > + Source8 = (CONST UINT8 *)Source32; > > > + } else { > > > + Destination8 = DestinationBuffer; > > > + Source8 = SourceBuffer; > > > + } > > > + while (Length-- != 0) { > > > + *Destination8++ = *Source8++; > > > + } > > > + return DestinationBuffer; > > > +} > > > + > > > +EFI_STATUS > > > +NorFlashReadBlocks ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN BufferSizeInBytes, > > > + OUT VOID *Buffer > > > + ) > > > +{ > > > + UINT32 NumBlocks; > > > + UINTN StartAddress; > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n", > > > + BufferSizeInBytes, Instance->BlockSize, Instance->LastBlock, Lba)); > > > + > > > + // The buffer must be valid > > > + if (Buffer == NULL) { > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // Return if we have not any byte to read > > > + if (BufferSizeInBytes == 0) { > > > + return EFI_SUCCESS; > > > + } > > > + > > > + // The size of the buffer must be a multiple of the block size > > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // All blocks must be within the device > > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > > + > > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashReadBlocks: ERROR - Read will exceed last block\n")); > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // Get the address to start reading from > > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > + Lba, > > > + Instance->BlockSize > > > + ); > > > + > > > + // Put the device into Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + // Readout the data > > > + AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes); > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +EFI_STATUS > > > +NorFlashRead ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN UINTN BufferSizeInBytes, > > > + OUT VOID *Buffer > > > + ) > > > +{ > > > + UINTN StartAddress; > > > + > > > + // The buffer must be valid > > > + if (Buffer == NULL) { > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // Return if we have not any byte to read > > > + if (BufferSizeInBytes == 0) { > > > + return EFI_SUCCESS; > > > + } > > > + > > > + if (((Lba * Instance->BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) { > > > + DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n")); > > > + return EFI_INVALID_PARAMETER; > > > + } > > > + > > > + // Get the address to start reading from > > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > + Lba, > > > + Instance->BlockSize > > > + ); > > > + > > > + // Put the device into Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + > > > + // Readout the data > > > + AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes); > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +/* > > > + Write a full or portion of a block. It must not span block boundaries; > > > + that is, Offset + *NumBytes <= Instance->Media.BlockSize. > > > +*/ > > > +EFI_STATUS > > > +NorFlashWriteSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN UINT8 *Buffer > > > + ) > > > +{ > > > + EFI_STATUS TempStatus; > > > + UINT32 Tmp; > > > + UINT32 TmpBuf; > > > + UINT32 WordToWrite; > > > + UINT32 Mask; > > > + BOOLEAN DoErase; > > > + UINTN BytesToWrite; > > > + UINTN CurOffset; > > > + UINTN WordAddr; > > > + UINTN BlockSize; > > > + UINTN BlockAddress; > > > + UINTN PrevBlockAddress; > > > + > > > + PrevBlockAddress = 0; > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > > + Lba, Offset, *NumBytes, Buffer)); > > > + > > > + // Cache the block size to avoid de-referencing pointers all the time > > > + BlockSize = Instance->BlockSize; > > > + > > > + // The write must not span block boundaries. > > > + // We need to check each variable individually because adding two > > > + // large values together overflows. > > > + if ( ( Offset >= BlockSize ) || > > > + ( *NumBytes > BlockSize ) || > > > + ( (Offset + *NumBytes) > BlockSize ) ) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > + Offset, *NumBytes, BlockSize )); > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // We must have some bytes to write > > > + if (*NumBytes == 0) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > + Offset, *NumBytes, BlockSize )); > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // Pick 128bytes as a good start for word operations as opposed to erasing the > > > + // block and writing the data regardless if an erase is really needed. > > > + // It looks like most individual NV variable writes are smaller than 128bytes. > > > + if (*NumBytes <= 128) { > > > + // Check to see if we need to erase before programming the data into NOR. > > > + // If the destination bits are only changing from 1s to 0s we can just write. > > > + // After a block is erased all bits in the block is set to 1. > > > + // If any byte requires us to erase we just give up and rewrite all of it. > > > + DoErase = FALSE; > > > + BytesToWrite = *NumBytes; > > > + CurOffset = Offset; > > > + > > > + while (BytesToWrite > 0) { > > > + // Read full word from NOR, splice as required. A word is the smallest > > > + // unit we can write. > > > + TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp); > > > + if (EFI_ERROR (TempStatus)) { > > > + return EFI_DEVICE_ERROR; > > > + } > > > + > > > + // Physical address of word in NOR to write. > > > + WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > + Lba, BlockSize); > > > + // The word of data that is to be written. > > > + TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite))); > > > + > > > + // First do word aligned chunks. > > > + if ((CurOffset & 0x3) == 0) { > > > + if (BytesToWrite >= 4) { > > > + // Is the destination still in 'erased' state? > > > + if (~Tmp != 0) { > > > + // Check to see if we are only changing bits to zero. > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > + DoErase = TRUE; > > > + break; > > > + } > > > + } > > > + // Write this word to NOR > > > + WordToWrite = TmpBuf; > > > + CurOffset += sizeof (TmpBuf); > > > + BytesToWrite -= sizeof (TmpBuf); > > > + } else { > > > + // BytesToWrite < 4. Do small writes and left-overs > > > + Mask = ~((~0) << (BytesToWrite * 8)); > > > + // Mask out the bytes we want. > > > + TmpBuf &= Mask; > > > + // Is the destination still in 'erased' state? > > > + if ((Tmp & Mask) != Mask) { > > > + // Check to see if we are only changing bits to zero. > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > + DoErase = TRUE; > > > + break; > > > + } > > > + } > > > + // Merge old and new data. Write merged word to NOR > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > + CurOffset += BytesToWrite; > > > + BytesToWrite = 0; > > > + } > > > + } else { > > > + // Do multiple words, but starting unaligned. > > > + if (BytesToWrite > (4 - (CurOffset & 0x3))) { > > > + Mask = ((~0) << ((CurOffset & 0x3) * 8)); > > > + // Mask out the bytes we want. > > > + TmpBuf &= Mask; > > > + // Is the destination still in 'erased' state? > > > + if ((Tmp & Mask) != Mask) { > > > + // Check to see if we are only changing bits to zero. > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > + DoErase = TRUE; > > > + break; > > > + } > > > + } > > > + // Merge old and new data. Write merged word to NOR > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > + BytesToWrite -= (4 - (CurOffset & 0x3)); > > > + CurOffset += (4 - (CurOffset & 0x3)); > > > + } else { > > > + // Unaligned and fits in one word. > > > + Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8); > > > + // Mask out the bytes we want. > > > + TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask; > > > + // Is the destination still in 'erased' state? > > > + if ((Tmp & Mask) != Mask) { > > > + // Check to see if we are only changing bits to zero. > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > + DoErase = TRUE; > > > + break; > > > + } > > > + } > > > + // Merge old and new data. Write merged word to NOR > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > + CurOffset += BytesToWrite; > > > + BytesToWrite = 0; > > > + } > > > + } > > > + > > > + // > > > + // Write the word to NOR. > > > + // > > > + > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize); > > > + if (BlockAddress != PrevBlockAddress) { > > > + TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > > + if (EFI_ERROR (TempStatus)) { > > > + return EFI_DEVICE_ERROR; > > > + } > > > + PrevBlockAddress = BlockAddress; > > > + } > > > + TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite); > > > + if (EFI_ERROR (TempStatus)) { > > > + return EFI_DEVICE_ERROR; > > > + } > > > + } > > > + // Exit if we got here and could write all the data. Otherwise do the > > > + // Erase-Write cycle. > > > + if (!DoErase) { > > > + return EFI_SUCCESS; > > > + } > > > + } > > > + > > > + // Check we did get some memory. Buffer is BlockSize. > > > + if (Instance->ShadowBuffer == NULL) { > > > + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n")); > > > + return EFI_DEVICE_ERROR; > > > + } > > > + > > > + // Read NOR Flash data into shadow buffer > > > + TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > > + if (EFI_ERROR (TempStatus)) { > > > + // Return one of the pre-approved error statuses > > > + return EFI_DEVICE_ERROR; > > > + } > > > + > > > + // Put the data at the appropriate location inside the buffer area > > > + CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes); > > > + > > > + // Write the modified buffer back to the NorFlash > > > + TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > > + if (EFI_ERROR (TempStatus)) { > > > + // Return one of the pre-approved error statuses > > > + return EFI_DEVICE_ERROR; > > > + } > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +EFI_STATUS > > > +NorFlashReset ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ) > > > +{ > > > + // As there is no specific RESET to perform, ensure that the devices > > > + // is in the default Read Array mode > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > + return EFI_SUCCESS; > > > +} > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > > new file mode 100644 > > > index 0000000..0396f7a > > > --- /dev/null > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > > @@ -0,0 +1,326 @@ > > > +/** @file NorFlash.h > > > + > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > + > > > + This program and the accompanying materials > > > + are licensed and made available under the terms and conditions of the BSD > > > + License which accompanies this distribution. The full text of the license > > > + may be found at http://opensource.org/licenses/bsd-license.php > > > + > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > + > > > +**/ > > > + > > > +#ifndef __NOR_FLASH_H__ > > > +#define __NOR_FLASH_H__ > > > + > > > +#include <Base.h> > > > +#include <Guid/EventGroup.h> > > > +#include <Library/DebugLib.h> > > > +#include <Library/IoLib.h> > > > +#include <Library/MmServicesTableLib.h> > > > +#include <Library/NorFlashPlatformLib.h> > > > +#include <Library/UefiLib.h> > > > +#include <Library/UefiRuntimeLib.h> > > > +#include <Protocol/FirmwareVolumeBlock.h> > > > + > > > +#define NOR_FLASH_ERASE_RETRY 10 > > > + > > > +// Device access macros > > > +// These are necessary because we use 2 x 16bit parts to make up 32bit data > > > + > > > +#define HIGH_16_BITS 0xFFFF0000 > > > +#define LOW_16_BITS 0x0000FFFF > > > +#define LOW_8_BITS 0x000000FF > > > + > > > +#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | \ > > > + ( value & LOW_16_BITS ) ) > > > + > > > +#define GET_LOW_BYTE(value) ( value & LOW_8_BITS ) > > > +#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE ( value >> 16 ) ) > > > + > > > +// Each command must be sent simultaneously to both chips, > > > +// i.e. at the lower 16 bits AND at the higher 16 bits > > > +#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr) ( ( BaseAddr ) + \ > > > + ( ( OffsetAddr ) << 2)) > > > +#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16 ) | \ > > > + ( Cmd & LOW_16_BITS ) ) > > > +#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 \ > > > + ( CREATE_NOR_ADDRESS ( BaseAddr,Offset ), \ > > > + CREATE_DUAL_CMD ( Cmd) ) > > > +#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + \ > > > + ( UINTN )( ( Lba ) * LbaSize ) ) > > > + > > > +// Status Register Bits > > > +#define P30_SR_BIT_WRITE ( BIT7 << 16 | BIT7 ) > > > +#define P30_SR_BIT_ERASE_SUSPEND ( BIT6 << 16 | BIT6 ) > > > +#define P30_SR_BIT_ERASE ( BIT5 << 16 | BIT5 ) > > > +#define P30_SR_BIT_PROGRAM ( BIT4 << 16 | BIT4 ) > > > +#define P30_SR_BIT_VPP ( BIT3 << 16 | BIT3 ) > > > +#define P30_SR_BIT_PROGRAM_SUSPEND ( BIT2 << 16 | BIT2 ) > > > +#define P30_SR_BIT_BLOCK_LOCKED ( BIT1 << 16 | BIT1 ) > > > +#define P30_SR_BIT_BEFP ( BIT0 << 16 | BIT0 ) > > > + > > > +// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family > > > + > > > +// On chip buffer size for buffered programming operations > > > +// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each > > > +// word is 2 bytes. > > > +// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes > > > +#define P30_MAX_BUFFER_SIZE_IN_BYTES ( ( UINTN ) 128 ) > > > +#define P30_MAX_BUFFER_SIZE_IN_WORDS ( P30_MAX_BUFFER_SIZE_IN_BYTES/ ( ( UINTN) 4 ) ) > > > +#define MAX_BUFFERED_PROG_ITERATIONS 10000000 > > > +#define BOUNDARY_OF_32_WORDS 0x7F > > > + > > > +// CFI Addresses > > > +#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10 > > > +#define P30_CFI_ADDR_VENDOR_ID 0x13 > > > + > > > +// CFI Data > > > +#define CFI_QRY 0x00595251 > > > + > > > +// READ Commands > > > +#define P30_CMD_READ_DEVICE_ID 0x0090 > > > +#define P30_CMD_READ_STATUS_REGISTER 0x0070 > > > +#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050 > > > +#define P30_CMD_READ_ARRAY 0x00FF > > > +#define P30_CMD_READ_CFI_QUERY 0x0098 > > > + > > > +// WRITE Commands > > > +#define P30_CMD_WORD_PROGRAM_SETUP 0x0040 > > > +#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010 > > > +#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8 > > > +#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0 > > > +#define P30_CMD_BEFP_SETUP 0x0080 > > > +#define P30_CMD_BEFP_CONFIRM 0x00D0 > > > + > > > +// ERASE Commands > > > +#define P30_CMD_BLOCK_ERASE_SETUP 0x0020 > > > +#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0 > > > + > > > +// SUSPEND Commands > > > +#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0 > > > +#define P30_CMD_SUSPEND_RESUME 0x00D0 > > > + > > > +// BLOCK LOCKING / UNLOCKING Commands > > > +#define P30_CMD_LOCK_BLOCK_SETUP 0x0060 > > > +#define P30_CMD_LOCK_BLOCK 0x0001 > > > +#define P30_CMD_UNLOCK_BLOCK 0x00D0 > > > +#define P30_CMD_LOCK_DOWN_BLOCK 0x002F > > > + > > > +// PROTECTION Commands > > > +#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0 > > > + > > > +// CONFIGURATION Commands > > > +#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060 > > > +#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003 > > > + > > > +#define NOR_FLASH_SIGNATURE SIGNATURE_32 ('n', 'o', 'r', '0') > > > +#define INSTANCE_FROM_FVB_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > + FvbProtocol, \ > > > + NOR_FLASH_SIGNATURE) > > > +#define INSTANCE_FROM_BLKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > + BlockIoProtocol, \ > > > + NOR_FLASH_SIGNATURE) > > > +#define INSTANCE_FROM_DISKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > + DiskIoProtocol, \ > > > + NOR_FLASH_SIGNATURE) > > > + > > > +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE; > > > +extern UINTN mFlashNvStorageVariableBase; > > > + > > > +#pragma pack (1) > > > +typedef struct { > > > + VENDOR_DEVICE_PATH Vendor; > > > + UINT8 Index; > > > + EFI_DEVICE_PATH_PROTOCOL End; > > > +} NOR_FLASH_DEVICE_PATH; > > > +#pragma pack () > > > + > > > +struct _NOR_FLASH_INSTANCE { > > > + UINT32 Signature; > > > + EFI_HANDLE Handle; > > > + > > > + UINTN DeviceBaseAddress; > > > + UINTN RegionBaseAddress; > > > + UINTN Size; > > > + UINT32 BlockSize; > > > + UINT32 LastBlock; > > > + EFI_LBA StartLba; > > > + > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol; > > > + VOID* ShadowBuffer; > > > + > > > + NOR_FLASH_DEVICE_PATH DevicePath; > > > +}; > > > + > > > +EFI_STATUS > > > +NorFlashWriteBuffer ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN TargetAddress, > > > + IN UINTN BufferSizeInBytes, > > > + IN UINT32 *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashCreateInstance ( > > > + IN UINTN NorFlashDeviceBase, > > > + IN UINTN NorFlashRegionBase, > > > + IN UINTN NorFlashSize, > > > + IN UINT32 Index, > > > + IN UINT32 BlockSize, > > > + IN BOOLEAN SupportFvb, > > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +NorFlashFvbInitialize ( > > > + IN NOR_FLASH_INSTANCE* Instance > > > + ); > > > + > > > +EFI_STATUS > > > +ValidateFvHeader ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ); > > > + > > > +EFI_STATUS > > > +InitializeFvAndVariableStoreHeaders ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +NorFlashFvbInitialize ( > > > + IN NOR_FLASH_INSTANCE* Instance > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetAttributes ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbSetAttributes ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetPhysicalAddress ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + OUT EFI_PHYSICAL_ADDRESS *Address > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetBlockSize ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + OUT UINTN *BlockSize, > > > + OUT UINTN *NumberOfBlocks > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbRead ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN OUT UINT8 *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbWrite ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN UINT8 *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +FvbEraseBlocks ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + ... > > > + ); > > > + > > > +typedef struct { > > > + EFI_TPL OriginalTPL; > > > +} NOR_FLASH_LOCK_CONTEXT; > > > + > > > +VOID > > > +EFIAPI > > > +NorFlashLock ( > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > + ); > > > + > > > +VOID > > > +EFIAPI > > > +NorFlashUnlock ( > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashUnlockAndEraseSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN UINTN BlockAddress > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashWriteSingleBlock ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN UINT8 *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashWriteBlocks ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN BufferSizeInBytes, > > > + IN VOID *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashReadBlocks ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN BufferSizeInBytes, > > > + OUT VOID *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashRead ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN UINTN BufferSizeInBytes, > > > + OUT VOID *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashWrite ( > > > + IN NOR_FLASH_INSTANCE *Instance, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN UINT8 *Buffer > > > + ); > > > + > > > +EFI_STATUS > > > +NorFlashReset ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ); > > > + > > > +#endif /* __NOR_FLASH_H__ */ > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > > new file mode 100644 > > > index 0000000..6ad3769 > > > --- /dev/null > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > > @@ -0,0 +1,740 @@ > > > +/*++ @file NorFlashFvb.c > > > + > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > + > > > + This program and the accompanying materials > > > + are licensed and made available under the terms and conditions of the > > > + BSD License which accompanies this distribution. The full text of the > > > + license may be found at http://opensource.org/licenses/bsd-license.php > > > + > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > + > > > + --*/ > > > + > > > +#include <Guid/VariableFormat.h> > > > +#include <Library/BaseMemoryLib.h> > > > +#include <Library/BaseLib.h> > > > +#include <Library/MemoryAllocationLib.h> > > > +#include <Library/PcdLib.h> > > > +#include <Library/UefiLib.h> > > > + > > > +#include "NorFlash.h" > > > + > > > +UINTN mFlashNvStorageVariableBase; > > > + > > > +/// > > > +/// The Firmware Volume Block Protocol is the low-level interface > > > +/// to a firmware volume. File-level access to a firmware volume > > > +/// should not be done using the Firmware Volume Block Protocol. > > > +/// Normal access to a firmware volume must use the Firmware > > > +/// Volume Protocol. Typically, only the file system driver that > > > +/// produces the Firmware Volume Protocol will bind to the > > > +/// Firmware Volume Block Protocol. > > > +/// > > > + > > > +/** > > > + Initialises the FV Header and Variable Store Header > > > + to support variable operations. > > > + > > > + @param[in] Ptr - Location to initialise the headers > > > + > > > +**/ > > > +EFI_STATUS > > > +InitializeFvAndVariableStoreHeaders ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + VOID* Headers; > > > + UINTN HeadersLength; > > > + EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader; > > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > > + > > > + HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + > > > + sizeof (VARIABLE_STORE_HEADER); > > > + Headers = AllocateZeroPool (HeadersLength); > > > + > > > + // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND > > > + // the FTW working area AND the FTW Spare contiguous. > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > + PcdGet32 (PcdFlashNvStorageVariableSize) == > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingBase)); > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) + > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) == > > > + PcdGet32 (PcdFlashNvStorageFtwSpareBase)); > > > + > > > + // Check if the size of the area is at least one block size > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageVariableSize) > 0) && > > > + (PcdGet32 (PcdFlashNvStorageVariableSize) / Instance->BlockSize > 0)); > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwWorkingSize) > 0) && > > > + (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) / Instance->BlockSize > 0)); > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwSpareSize) > 0) && > > > + (PcdGet32 (PcdFlashNvStorageFtwSpareSize) / Instance->BlockSize > 0)); > > > + > > > + // Ensure the Variable area Base Addresses are aligned on a > > > + // block size boundaries > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) % Instance->BlockSize == 0); > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) % Instance->BlockSize == 0); > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwSpareBase) % Instance->BlockSize == 0); > > > + > > > + // > > > + // EFI_FIRMWARE_VOLUME_HEADER > > > + // > > > + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers; > > > + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid); > > > + FirmwareVolumeHeader->FvLength = > > > + PcdGet32 (PcdFlashNvStorageVariableSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > > + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE; > > > + FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) ( > > > + EFI_FVB2_READ_ENABLED_CAP | > > > + // Reads may be enabled > > > + EFI_FVB2_READ_STATUS | > > > + // Reads are currently enabled > > > + EFI_FVB2_STICKY_WRITE | > > > + // A block erase is required to flip > > > + // bits into EFI_FVB2_ERASE_POLARITY > > > + EFI_FVB2_MEMORY_MAPPED | > > > + // It is memory mapped > > > + EFI_FVB2_ERASE_POLARITY | > > > + // After erasure all bits take this > > > + // value (i.e. '1') > > > + EFI_FVB2_WRITE_STATUS | > > > + // Writes are currently enabled > > > + EFI_FVB2_WRITE_ENABLED_CAP > > > + // Writes may be enabled > > > + ); > > > + FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY); > > > + FirmwareVolumeHeader->Revision = EFI_FVH_REVISION; > > > + FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->LastBlock + 1; > > > + FirmwareVolumeHeader->BlockMap[0].Length = Instance->BlockSize; > > > + FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0; > > > + FirmwareVolumeHeader->BlockMap[1].Length = 0; > > > + FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ( > > > + (UINT16*)FirmwareVolumeHeader, > > > + FirmwareVolumeHeader->HeaderLength); > > > + > > > + // > > > + // VARIABLE_STORE_HEADER > > > + // > > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)Headers + > > > + FirmwareVolumeHeader->HeaderLength); > > > + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid); > > > + VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - > > > + FirmwareVolumeHeader->HeaderLength; > > > + VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED; > > > + VariableStoreHeader->State = VARIABLE_STORE_HEALTHY; > > > + > > > + // Install the combined super-header in the NorFlash > > > + Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers); > > > + > > > + FreePool (Headers); > > > + return Status; > > > +} > > > + > > > +/** > > > + Check the integrity of firmware volume header. > > > + > > > + @param[in] FwVolHeader - A pointer to a firmware volume header > > > + > > > + @retval EFI_SUCCESS - The firmware volume is consistent > > > + @retval EFI_NOT_FOUND - The firmware volume has been corrupted. > > > + > > > +**/ > > > +EFI_STATUS > > > +ValidateFvHeader ( > > > + IN NOR_FLASH_INSTANCE *Instance > > > + ) > > > +{ > > > + UINT16 Checksum; > > > + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; > > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > > + UINTN VariableStoreLength; > > > + UINTN FvLength; > > > + > > > + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress; > > > + > > > + FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > > + > > > + // > > > + // Verify the header revision, header signature, length > > > + // Length of FvBlock cannot be 2**64-1 > > > + // HeaderLength cannot be an odd number > > > + // > > > + if ( (FwVolHeader->Revision != EFI_FVH_REVISION) > > > + || (FwVolHeader->Signature != EFI_FVH_SIGNATURE) > > > + || (FwVolHeader->FvLength != FvLength) > > > + ) > > > + { > > > + DEBUG ((DEBUG_INFO, "%a: No Firmware Volume header present\n", > > > + __FUNCTION__)); > > > + return EFI_NOT_FOUND; > > > + } > > > + > > > + // Check the Firmware Volume Guid > > > + if (CompareGuid (&FwVolHeader->FileSystemGuid, > > > + &gEfiSystemNvDataFvGuid) == FALSE ) { > > > + DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\n", > > > + __FUNCTION__)); > > > + return EFI_NOT_FOUND; > > > + } > > > + > > > + // Verify the header checksum > > > + Checksum = CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader->HeaderLength); > > > + if (Checksum != 0) { > > > + DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n", > > > + __FUNCTION__, Checksum)); > > > + return EFI_NOT_FOUND; > > > + } > > > + > > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)FwVolHeader + > > > + FwVolHeader->HeaderLength); > > > + > > > + // Check the Variable Store Guid > > > + if (!CompareGuid (&VariableStoreHeader->Signature, > > > + &gEfiVariableGuid) && > > > + !CompareGuid (&VariableStoreHeader->Signature, > > > + &gEfiAuthenticatedVariableGuid)) { > > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Guid non-compatible\n", > > > + __FUNCTION__)); > > > + return EFI_NOT_FOUND; > > > + } > > > + > > > + VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - > > > + FwVolHeader->HeaderLength; > > > + if (VariableStoreHeader->Size != VariableStoreLength) { > > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Length does not match\n", > > > + __FUNCTION__)); > > > + return EFI_NOT_FOUND; > > > + } > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +/** > > > + The GetAttributes() function retrieves the attributes and > > > + current settings of the block. > > > + > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > + > > > + @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and > > > + current settings are returned. > > > + Type EFI_FVB_ATTRIBUTES_2 is defined in > > > + EFI_FIRMWARE_VOLUME_HEADER. > > > + > > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetAttributes ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > + ) > > > +{ > > > + EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes; > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) ( > > > + > > > + EFI_FVB2_READ_ENABLED_CAP | > > > + // Reads may be enabled > > > + EFI_FVB2_READ_STATUS | > > > + // Reads are currently enabled > > > + EFI_FVB2_WRITE_ENABLED_CAP | > > > + // Writes may be enabled > > > + EFI_FVB2_WRITE_STATUS | > > > + // Writes are currently enabled > > > + EFI_FVB2_STICKY_WRITE | > > > + // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY > > > + EFI_FVB2_MEMORY_MAPPED | > > > + // It is memory mapped > > > + EFI_FVB2_ERASE_POLARITY > > > + // After erasure all bits take this value (i.e. '1') > > > + > > > + ); > > > + > > > + *Attributes = FlashFvbAttributes; > > > + > > > + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes)); > > > + > > > + return EFI_SUCCESS; > > > +} > > > + > > > +/** > > > + The SetAttributes() function sets configurable firmware volume attributes > > > + and returns the new settings of the firmware volume. > > > + > > > + > > > + @param This Indicates the > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > + > > > + @param Attributes On input, Attributes is a pointer to > > > + EFI_FVB_ATTRIBUTES_2 that contains the desired > > > + firmware volume settings. On successful return, > > > + it contains the new settings of the firmware > > > + volume. Type EFI_FVB_ATTRIBUTES_2 is defined > > > + in EFI_FIRMWARE_VOLUME_HEADER. > > > + > > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > > + > > > + @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with > > > + the capabilities > > > + as declared in the firmware volume header. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbSetAttributes ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > + ) > > > +{ > > > + DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes)); > > > + return EFI_UNSUPPORTED; > > > +} > > > + > > > +/** > > > + The GetPhysicalAddress() function retrieves the base address of > > > + a memory-mapped firmware volume. This function should be called > > > + only for memory-mapped firmware volumes. > > > + > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > + instance. > > > + > > > + @param Address Pointer to a caller-allocated > > > + EFI_PHYSICAL_ADDRESS that, on successful > > > + return from GetPhysicalAddress(), contains the > > > + base address of the firmware volume. > > > + > > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > > + > > > + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetPhysicalAddress ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + OUT EFI_PHYSICAL_ADDRESS *Address > > > + ) > > > +{ > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", > > > + Instance->RegionBaseAddress)); > > > + > > > + ASSERT (Address != NULL); > > > + > > > + *Address = mFlashNvStorageVariableBase; > > > + return EFI_SUCCESS; > > > +} > > > + > > > +/** > > > + The GetBlockSize() function retrieves the size of the requested > > > + block. It also returns the number of additional blocks with > > > + the identical size. The GetBlockSize() function is used to > > > + retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER). > > > + > > > + > > > + @param This Indicates the > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > + > > > + @param Lba Indicates the block for which to return > > > + the size. > > > + > > > + @param BlockSize Pointer to a caller-allocated UINTN in which > > > + the size of the block is returned. > > > + > > > + @param NumberOfBlocks Pointer to a caller-allocated UINTN in > > > + which the number of consecutive blocks, > > > + starting with Lba, is returned. All > > > + blocks in this range have a size of > > > + BlockSize. > > > + > > > + > > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > > + > > > + @retval EFI_INVALID_PARAMETER The requested LBA is out of range. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbGetBlockSize ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + OUT UINTN *BlockSize, > > > + OUT UINTN *NumberOfBlocks > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", > > > + Lba, Instance->BlockSize, Instance->LastBlock)); > > > + > > > + if (Lba > Instance->LastBlock) { > > > + DEBUG ((DEBUG_ERROR, > > > + "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", > > > + Lba, Instance->LastBlock)); > > > + Status = EFI_INVALID_PARAMETER; > > > + } else { > > > + // This is easy because in this platform each NorFlash device > > > + // has equal sized blocks. > > > + *BlockSize = (UINTN) Instance->BlockSize; > > > + *NumberOfBlocks = (UINTN) (Instance->LastBlock - Lba + 1); > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "FvbGetBlockSize: *BlockSize=0x%x,*NumberOfBlocks=0x%x.\n", > > > + *BlockSize, *NumberOfBlocks)); > > > + > > > + Status = EFI_SUCCESS; > > > + } > > > + > > > + return Status; > > > +} > > > + > > > +/** > > > + Reads the specified number of bytes into a buffer from the specified block. > > > + > > > + The Read() function reads the requested number of bytes from the > > > + requested block and stores them in the provided buffer. > > > + Implementations should be mindful that the firmware volume > > > + might be in the ReadDisabled state. If it is in this state, > > > + the Read() function must return the status code > > > + EFI_ACCESS_DENIED without modifying the contents of the > > > + buffer. The Read() function must also prevent spanning block > > > + boundaries. If a read is requested that would span a block > > > + boundary, the read must read up to the boundary but not > > > + beyond. The output parameter NumBytes must be set to correctly > > > + indicate the number of bytes actually read. The caller must be > > > + aware that a read may be partially completed. > > > + > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > + instance. > > > + > > > + @param Lba The starting logical block index from which to read. > > > + > > > + @param Offset Offset into the block at which to begin reading. > > > + > > > + @param NumBytes Pointer to a UINTN. > > > + At entry, *NumBytes contains the total size of the buffer. > > > + At exit, *NumBytes contains the total number of bytes read. > > > + > > > + @param Buffer Pointer to a caller-allocated buffer that will be used > > > + to hold the data that is read. > > > + > > > + @retval EFI_SUCCESS The firmware volume was read successfully,and contents are > > > + in Buffer. > > > + > > > + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary. > > > + On output, NumBytes contains the total number of bytes > > > + returned in Buffer. > > > + > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state. > > > + > > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and > > > + could not be read. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbRead ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN OUT UINT8 *Buffer > > > + ) > > > +{ > > > + EFI_STATUS TempStatus; > > > + UINTN BlockSize; > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > > + Instance->StartLba + Lba, Offset, *NumBytes, Buffer)); > > > + > > > + TempStatus = EFI_SUCCESS; > > > + > > > + // Cache the block size to avoid de-referencing pointers all the time > > > + BlockSize = Instance->BlockSize; > > > + > > > + DEBUG ((DEBUG_BLKIO, > > > + "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", > > > + Offset, *NumBytes, BlockSize )); > > > + > > > + // The read must not span block boundaries. > > > + // We need to check each variable individually because adding two > > > + // large values together overflows. > > > + if ((Offset >= BlockSize) || > > > + (*NumBytes > BlockSize) || > > > + ((Offset + *NumBytes) > BlockSize)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > + Offset, *NumBytes, BlockSize )); > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // We must have some bytes to read > > > + if (*NumBytes == 0) { > > > + return EFI_BAD_BUFFER_SIZE; > > > + } > > > + > > > + // Decide if we are doing full block reads or not. > > > + if (*NumBytes % BlockSize != 0) { > > > + TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer); > > > + if (EFI_ERROR (TempStatus)) { > > > + return EFI_DEVICE_ERROR; > > > + } > > > + } else { > > > + // Read NOR Flash data into shadow buffer > > > + TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer); > > > + if (EFI_ERROR (TempStatus)) { > > > + // Return one of the pre-approved error statuses > > > + return EFI_DEVICE_ERROR; > > > + } > > > + } > > > + return EFI_SUCCESS; > > > +} > > > + > > > +/** > > > + Writes the specified number of bytes from the input buffer to the block. > > > + > > > + The Write() function writes the specified number of bytes from > > > + the provided buffer to the specified block and offset. If the > > > + firmware volume is sticky write, the caller must ensure that > > > + all the bits of the specified range to write are in the > > > + EFI_FVB_ERASE_POLARITY state before calling the Write() > > > + function, or else the result will be unpredictable. This > > > + unpredictability arises because, for a sticky-write firmware > > > + volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY > > > + state but cannot flip it back again. Before calling the > > > + Write() function, it is recommended for the caller to first call > > > + the EraseBlocks() function to erase the specified block to > > > + write. A block erase cycle will transition bits from the > > > + (NOT)EFI_FVB_ERASE_POLARITY state back to the > > > + EFI_FVB_ERASE_POLARITY state. Implementations should be > > > + mindful that the firmware volume might be in the WriteDisabled > > > + state. If it is in this state, the Write() function must > > > + return the status code EFI_ACCESS_DENIED without modifying the > > > + contents of the firmware volume. The Write() function must > > > + also prevent spanning block boundaries. If a write is > > > + requested that spans a block boundary, the write must store up > > > + to the boundary but not beyond. The output parameter NumBytes > > > + must be set to correctly indicate the number of bytes actually > > > + written. The caller must be aware that a write may be > > > + partially completed. All writes, partial or otherwise, must be > > > + fully flushed to the hardware before the Write() service > > > + returns. > > > + > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > + instance. > > > + > > > + @param Lba The starting logical block index to write to. > > > + > > > + @param Offset Offset into the block at which to begin writing. > > > + > > > + @param NumBytes The pointer to a UINTN. > > > + At entry, *NumBytes contains the total size of the > > > + buffer. > > > + At exit, *NumBytes contains the total number of > > > + bytes actually written. > > > + > > > + @param Buffer The pointer to a caller-allocated buffer that contains > > > + the source for the write. > > > + > > > + @retval EFI_SUCCESS The firmware volume was written successfully. > > > + > > > + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary. > > > + On output, NumBytes contains the total number of bytes > > > + actually written. > > > + > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > > + > > > + @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not > > > + be written. > > > + > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbWrite ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + IN EFI_LBA Lba, > > > + IN UINTN Offset, > > > + IN OUT UINTN *NumBytes, > > > + IN UINT8 *Buffer > > > + ) > > > +{ > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer); > > > +} > > > + > > > +/** > > > + Erases and initialises a firmware volume block. > > > + > > > + The EraseBlocks() function erases one or more blocks as denoted > > > + by the variable argument list. The entire parameter list of > > > + blocks must be verified before erasing any blocks. If a block is > > > + requested that does not exist within the associated firmware > > > + volume (it has a larger index than the last block of the > > > + firmware volume), the EraseBlocks() function must return the > > > + status code EFI_INVALID_PARAMETER without modifying the contents > > > + of the firmware volume. Implementations should be mindful that > > > + the firmware volume might be in the WriteDisabled state. If it > > > + is in this state, the EraseBlocks() function must return the > > > + status code EFI_ACCESS_DENIED without modifying the contents of > > > + the firmware volume. All calls to EraseBlocks() must be fully > > > + flushed to the hardware before the EraseBlocks() service > > > + returns. > > > + > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > + instance. > > > + > > > + @param ... The variable argument list is a list of tuples. > > > + Each tuple describes a range of LBAs to erase > > > + and consists of the following: > > > + - An EFI_LBA that indicates the starting LBA > > > + - A UINTN that indicates the number of blocks > > > + to erase. > > > + > > > + The list is terminated with an > > > + EFI_LBA_LIST_TERMINATOR. > > > + For example, the following indicates that two > > > + ranges of blocks (5-7 and 10-11) are to be erased: > > > + EraseBlocks (This, 5, 3, 10, 2, > > > + EFI_LBA_LIST_TERMINATOR); > > > + > > > + @retval EFI_SUCCESS The erase request successfully completed. > > > + > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > > + > > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly > > > + and could not be written. > > > + The firmware device may have been partially erased. > > > + > > > + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable > > > + argument list do not exist in the firmware volume. > > > + > > > + **/ > > > +EFI_STATUS > > > +EFIAPI > > > +FvbEraseBlocks ( > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > + ... > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + VA_LIST Args; > > > + UINTN BlockAddress; // Physical address of Lba to erase > > > + EFI_LBA StartingLba; // Lba from which we start erasing > > > + UINTN NumOfLba; // Number of Lba blocks to erase > > > + NOR_FLASH_INSTANCE *Instance; > > > + > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > + > > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n")); > > > + > > > + Status = EFI_SUCCESS; > > > + > > > + // Before erasing, check the entire list of parameters to > > > + // ensure all specified blocks are valid > > > + > > > + VA_START (Args, This); > > > + do { > > > + // Get the Lba from which we start erasing > > > + StartingLba = VA_ARG (Args, EFI_LBA); > > > + > > > + // Have we reached the end of the list? > > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > > + //Exit the while loop > > > + break; > > > + } > > > + > > > + // How many Lba blocks are we requested to erase? > > > + NumOfLba = VA_ARG (Args, UINTN); > > > + > > > + // All blocks must be within range > > > + DEBUG (( > > > + DEBUG_BLKIO, > > > + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n", > > > + Instance->StartLba + StartingLba, > > > + (UINT64)NumOfLba, > > > + Instance->LastBlock > > > + )); > > > + if ((NumOfLba == 0) || > > > + ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->LastBlock)) { > > > + VA_END (Args); > > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n")); > > > + Status = EFI_INVALID_PARAMETER; > > > + goto EXIT; > > > + } > > > + } while (TRUE); > > > + VA_END (Args); > > > + > > > + // > > > + // To get here, all must be ok, so start erasing > > > + // > > > + VA_START (Args, This); > > > + do { > > > + // Get the Lba from which we start erasing > > > + StartingLba = VA_ARG (Args, EFI_LBA); > > > + > > > + // Have we reached the end of the list? > > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > > + // Exit the while loop > > > + break; > > > + } > > > + > > > + // How many Lba blocks are we requested to erase? > > > + NumOfLba = VA_ARG (Args, UINTN); > > > + > > > + // Go through each one and erase it > > > + while (NumOfLba > 0) { > > > + > > > + // Get the physical address of Lba to erase > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS ( > > > + Instance->RegionBaseAddress, > > > + Instance->StartLba + StartingLba, > > > + Instance->BlockSize > > > + ); > > > + > > > + // Erase it > > > + DEBUG ((DEBUG_BLKIO, > > > + "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", > > > + Instance->StartLba + StartingLba, BlockAddress)); > > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > > + if (EFI_ERROR (Status)) { > > > + VA_END (Args); > > > + Status = EFI_DEVICE_ERROR; > > > + goto EXIT; > > > + } > > > + > > > + // Move to the next Lba > > > + StartingLba++; > > > + NumOfLba--; > > > + } > > > + } while (TRUE); > > > + VA_END (Args); > > > + > > > +EXIT: > > > + return Status; > > > +} > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > > new file mode 100644 > > > index 0000000..08e20ae > > > --- /dev/null > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > > @@ -0,0 +1,250 @@ > > > +/*++ @file NorFlashStandaloneMm.c > > > + > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > + > > > + This program and the accompanying materials > > > + are licensed and made available under the terms and conditions of the BSD > > > + License which accompanies this distribution. The full text of the license > > > + may be found at http://opensource.org/licenses/bsd-license.php > > > + > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > + > > > + --*/ > > > + > > > +#include <PiMm.h> > > > + > > > +#include <Library/BaseLib.h> > > > +#include <Library/BaseMemoryLib.h> > > > +#include <Library/MemoryAllocationLib.h> > > > +#include <Library/PcdLib.h> > > > + > > > +#include "NorFlash.h" > > > + > > > +// > > > +// Global variable declarations > > > +// > > > +STATIC NOR_FLASH_INSTANCE **mNorFlashInstances; > > > +STATIC UINT32 mNorFlashDeviceCount; > > > + > > > +STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = { > > > + NOR_FLASH_SIGNATURE, // Signature > > > + NULL, // Handle ... NEED TO BE FILLED > > > + > > > + 0, // DeviceBaseAddress ... NEED TO BE FILLED > > > + 0, // RegionBaseAddress ... NEED TO BE FILLED > > > + 0, // Size ... NEED TO BE FILLED > > > + 0, // BlockSize ... NEED TO BE FILLED > > > + 0, // LastBlock ... NEED TO BE FILLED > > > + 0, // StartLba ... NEED TO BE FILLED > > > + > > > + { > > > + FvbGetAttributes, // GetAttributes > > > + FvbSetAttributes, // SetAttributes > > > + FvbGetPhysicalAddress, // GetPhysicalAddress > > > + FvbGetBlockSize, // GetBlockSize > > > + FvbRead, // Read > > > + FvbWrite, // Write > > > + FvbEraseBlocks, // EraseBlocks > > > + NULL, //ParentHandle > > > + }, // FvbProtoccol; > > > + NULL, // ShadowBuffer > > > + { > > > + { > > > + { > > > + HARDWARE_DEVICE_PATH, > > > + HW_VENDOR_DP, > > > + { > > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)), > > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8) > > > + } > > > + }, > > > + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, > > > + // GUID ... NEED TO BE FILLED > > > + }, > > > + 0, // Index > > > + { > > > + END_DEVICE_PATH_TYPE, > > > + END_ENTIRE_DEVICE_PATH_SUBTYPE, > > > + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } > > > + } > > > + } // DevicePath > > > +}; > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +NorFlashFvbInitialize ( > > > + IN NOR_FLASH_INSTANCE* Instance > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINT32 FvbNumLba; > > > + > > > + DEBUG ((DEBUG_BLKIO,"NorFlashFvbInitialize\n")); > > > + ASSERT ((Instance != NULL)); > > > + > > > + mFlashNvStorageVariableBase = FixedPcdGet32 (PcdFlashNvStorageVariableBase); > > > + > > > + // Set the index of the first LBA for the FVB > > > + Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - > > > + Instance->RegionBaseAddress) / Instance->BlockSize; > > > + > > > + // Determine if there is a valid header at the beginning of the NorFlash > > > + Status = ValidateFvHeader (Instance); > > > + > > > + // Install the Default FVB header if required > > > + if (EFI_ERROR (Status)) { > > > + // There is no valid header, so time to install one. > > > + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__)); > > > + DEBUG ((DEBUG_INFO, "%a: Installing a correct one for this volume.\n", > > > + __FUNCTION__)); > > > + > > > + // Erase all the NorFlash that is reserved for variable storage > > > + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / > > > + Instance->BlockSize; > > > + > > > + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, > > > + EFI_LBA_LIST_TERMINATOR); > > > + if (EFI_ERROR (Status)) { > > > + return Status; > > > + } > > > + > > > + // Install all appropriate headers > > > + Status = InitializeFvAndVariableStoreHeaders (Instance); > > > + if (EFI_ERROR (Status)) { > > > + return Status; > > > + } > > > + } > > > + > > > + return Status; > > > +} > > > + > > > +VOID > > > +EFIAPI > > > +NorFlashLock ( > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > + ) > > > +{ > > > +} > > > + > > > +VOID > > > +EFIAPI > > > +NorFlashUnlock ( > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > + ) > > > +{ > > > +} > > > + > > > +EFI_STATUS > > > +NorFlashCreateInstance ( > > > + IN UINTN NorFlashDeviceBase, > > > + IN UINTN NorFlashRegionBase, > > > + IN UINTN NorFlashSize, > > > + IN UINT32 Index, > > > + IN UINT32 BlockSize, > > > + IN BOOLEAN SupportFvb, > > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + NOR_FLASH_INSTANCE* Instance; > > > + > > > + ASSERT (NorFlashInstance != NULL); > > > + > > > + Instance = AllocateCopyPool (sizeof (NOR_FLASH_INSTANCE), > > > + &mNorFlashInstanceTemplate); > > > + if (Instance == NULL) { > > > + return EFI_OUT_OF_RESOURCES; > > > + } > > > + > > > + Instance->DeviceBaseAddress = NorFlashDeviceBase; > > > + Instance->RegionBaseAddress = NorFlashRegionBase; > > > + Instance->Size = NorFlashSize; > > > + > > > + Instance->BlockSize = BlockSize; > > > + Instance->LastBlock = (NorFlashSize / BlockSize)-1; > > > + > > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid); > > > + Instance->DevicePath.Index = (UINT8)Index; > > > + > > > + NorFlashReset (Instance); > > > + > > > + Instance->ShadowBuffer = AllocatePool (BlockSize);; > > > + if (Instance->ShadowBuffer == NULL) { > > > + return EFI_OUT_OF_RESOURCES; > > > + } > > > + > > > + if (SupportFvb) { > > > + NorFlashFvbInitialize (Instance); > > > + > > > + //Install FirmwareVolumeBlock Protocol > > > + Status = gMmst->MmInstallProtocolInterface ( > > > + &Instance->Handle, > > > + &gEfiSmmFirmwareVolumeBlockProtocolGuid, > > > + EFI_NATIVE_INTERFACE, > > > + &Instance->FvbProtocol > > > + ); > > > + if (EFI_ERROR (Status)) { > > > + FreePool (Instance); > > > + return Status; > > > + } > > > + } > > > + > > > + *NorFlashInstance = Instance; > > > + return Status; > > > +} > > > + > > > +EFI_STATUS > > > +EFIAPI > > > +NorFlashInitialise ( > > > + IN EFI_HANDLE ImageHandle, > > > + IN EFI_MM_SYSTEM_TABLE *SystemTable > > > + ) > > > +{ > > > + EFI_STATUS Status; > > > + UINT32 Index; > > > + NOR_FLASH_DESCRIPTION* NorFlashDevices; > > > + BOOLEAN ContainVariableStorage; > > > + > > > + Status = NorFlashPlatformInitialization (); > > > + if (EFI_ERROR (Status)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashInitialise: Fail to initialize Nor Flash devices\n")); > > > + return Status; > > > + } > > > + > > > + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount); > > > + if (EFI_ERROR (Status)) { > > > + DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n")); > > > + return Status; > > > + } > > > + > > > + mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE*) * mNorFlashDeviceCount); > > > + > > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > > + // Check if this NOR Flash device contain the variable storage region > > > + ContainVariableStorage = > > > + (NorFlashDevices[Index].RegionBaseAddress <= > > > + PcdGet32 (PcdFlashNvStorageVariableBase)) && > > > + (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > + PcdGet32 (PcdFlashNvStorageVariableSize) <= > > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > > + > > > + Status = NorFlashCreateInstance ( > > > + NorFlashDevices[Index].DeviceBaseAddress, > > > + NorFlashDevices[Index].RegionBaseAddress, > > > + NorFlashDevices[Index].Size, > > > + Index, > > > + NorFlashDevices[Index].BlockSize, > > > + ContainVariableStorage, > > > + &mNorFlashInstances[Index] > > > + ); > > > + if (EFI_ERROR (Status)) { > > > + DEBUG ((DEBUG_ERROR, > > > + "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index)); > > > + } > > > + } > > > + return Status; > > > +} > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > > new file mode 100644 > > > index 0000000..12073fc > > > --- /dev/null > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > > @@ -0,0 +1,68 @@ > > > +#/** @file > > > +# > > > +# Component description file for NorFlashStandaloneMm module > > > +# > > > +# Copyright (c) 2019, ARM Ltd. All rights reserved.<BR> > > > +# > > > +# This program and the accompanying materials > > > +# are licensed and made available under the terms and conditions of the BSD License > > > +# which accompanies this distribution. The full text of the license may be found at > > > +# http://opensource.org/licenses/bsd-license.php > > > +# > > > +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > +# > > > +#**/ > > > + > > > +[Defines] > > > + INF_VERSION = 0x00010005 > > > + BASE_NAME = StandaloneMmNorFlash > > > + FILE_GUID = 166F677B-DAC9-4AE4-AD34-2FF2504B0637 > > > + MODULE_TYPE = MM_STANDALONE > > > + VERSION_STRING = 1.0 > > > + PI_SPECIFICATION_VERSION = 0x00010032 > > > + ENTRY_POINT = NorFlashInitialise > > > + > > > +[Sources.common] > > > + NorFlash.c > > > + NorFlashFvb.c > > > + NorFlashStandaloneMm.c > > > + > > > +[Packages] > > > + ArmPkg/ArmPkg.dec > > > + ArmPlatformPkg/ArmPlatformPkg.dec > > > + MdePkg/MdePkg.dec > > > + MdeModulePkg/MdeModulePkg.dec > > > + StandaloneMmPkg/StandaloneMmPkg.dec > > > + > > > +[LibraryClasses] > > > + ArmLib > > > + ArmSvcLib > > > + BaseMemoryLib > > > + BaseLib > > > + DebugLib > > > + MemoryAllocationLib > > > + MmServicesTableLib > > > + NorFlashPlatformLib > > > + StandaloneMmDriverEntryPoint > > > + > > > +[Guids] > > > + gEfiSystemNvDataFvGuid > > > + gEfiVariableGuid > > > + gEfiAuthenticatedVariableGuid > > > + > > > +[Protocols] > > > + gEfiSmmFirmwareVolumeBlockProtocolGuid > > > + > > > +[Pcd.common] > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize > > > + > > > + gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked > > > + > > > +[Depex] > > > + TRUE > > > -- > > > 2.7.4 > > > > > > _______________________________________________ > > > edk2-devel mailing list > > > edk2-devel@lists.01.org > > > https://lists.01.org/mailman/listinfo/edk2-devel > > > ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-24 13:06 ` [edk2-devel] " Ard Biesheuvel @ 2019-04-29 5:59 ` Jagadeesh Ujja 2019-04-29 6:52 ` Ard Biesheuvel 0 siblings, 1 reply; 10+ messages in thread From: Jagadeesh Ujja @ 2019-04-29 5:59 UTC (permalink / raw) To: devel, Ard Biesheuvel; +Cc: Leif Lindholm hi Ard On Wed, Apr 24, 2019 at 6:37 PM Ard Biesheuvel <ard.biesheuvel@linaro.org> wrote: > > On Wed, 24 Apr 2019 at 11:05, Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > Fwd to new EDKII development mailing list. > > > > hi Ard, > > > > Sorry about missing your previous comment and adding here. > > > > "Hello Jagadeesh, > > > > Why are you moving this driver into edk2-platforms? I'd prefer to have > > > > it alongside the non-MM version instead. > > > > That would allow us to share a lot more code between the two versions." > > ----------------- > > > > my Point of view: > > > > In ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and > > disk I/O protocols. > > In case of StandaloneMM norflash driver the block I/O and disk I/O > > protocols are not required > > > > We don’t want to remove support of block I/O and disk I/O protocols in > > “ArmPlatformPkg/Drivers/NorFlashDxe” > > In this case “NOR_FLASH_INSTANCE” is different in both > > drivers(DXE/STANDALONEMM). So we end up with having 2 different > > drivers. > > > > Even if we want to share common code then we end up with multiple > > files as “NOR_FLASH_INSTANCE” is used in almost all files > > Ex: “NorFlash.c” “NorFlash.h” NorFlashFvb.c > > In this case “NorFlash.c” will have 2 copies one used by DXE and > > other by STANDALONE_MM driver > > > > So instead of having 2 different drivers in one place > > “ArmPlatformPkg/Drivers/NorFlashDxe” > > added a new refactored nor flash driver in "Platform/ARM/Drivers" > > > > I am not sure if any other platform is using > > “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and > > disk I/O protocols > > if we remove “support of block I/O and disk I/O protocols” then we > > can share the common code easily. > > > > I see your point. > > The only reason you need block i/o and disk i/o is to use ordinary > partition and filesystem drivers. I guess Juno uses this for its magic > filesystem? If not, I'd be glad to get rid of it. > > Yes "block i/o and disk i/o of “ArmPlatformPkg/Drivers/NorFlashDxe” driver is used even in RD-platforms(edk2-platforms/Platform/ARM/SgiPkg/)(and JUNO) to list partition. we don't want to break legacy and want to have separate "Platform/ARM/Drivers/StandaloneMmNorFlash/" driver. thanks Jagadeesh > > > > On Mon, Apr 8, 2019 at 7:16 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > > > hi Ard/Leif > > > > > > Please let me know if you have any comments on this patch set > > > thanks > > > Jagadeesh > > > > > > On Tue, Apr 2, 2019 at 6:48 PM Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > > > > > Refactor the existing ArmPlatformPkg NOR flash driver to be usable > > > > as a StandaloneMM library. Some of the functionality not required > > > > in StandaloneMM, such as the block layer, is removed. This allows > > > > storing of EFI variables on NOR flash which is accessible only via > > > > the MM STANDALONE mode software > > > > > > > > Contributed-under: TianoCore Contribution Agreement 1.1 > > > > Signed-off-by: Jagadeesh Ujja <jagadeesh.ujja@arm.com> > > > > --- > > > > Changes since v1: > > > > - This is a next version of patch > > > > “[edk2] [PATCH 0/2] Allow use of ArmPlatformPkg NOR flash driver in StandaloneMM” > > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036882.html > > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036884.html > > > > https://lists.01.org/pipermail/edk2-devel/2019-February/036883.html > > > > - ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and disk > > > > I/O protocols. This driver is required in StandaloneMM but the block I/O > > > > and disk I/O protocols are not required in StandaloneMM. > > > > - Instead of removing support for block I/O and disk I/O protocols, > > > > add a new refactored nor flash driver in "Platform/ARM/Drivers" > > > > - Addressed all the comments from Ard Biesheuvel. > > > > > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c | 982 ++++++++++++++++++++ > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h | 326 +++++++ > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c | 740 +++++++++++++++ > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c | 250 +++++ > > > > Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf | 68 ++ > > > > 5 files changed, 2366 insertions(+) > > > > > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > > > new file mode 100644 > > > > index 0000000..4ba4fb5 > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.c > > > > @@ -0,0 +1,982 @@ > > > > +/** @file NorFlash.c > > > > + > > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > > + > > > > + This program and the accompanying materials > > > > + are licensed and made available under the terms and conditions of the > > > > + BSD License which accompanies this distribution. The full text of the > > > > + license may be found at http://opensource.org/licenses/bsd-license.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > > + > > > > +**/ > > > > + > > > > +#include <Library/BaseMemoryLib.h> > > > > +#include <Library/MemoryAllocationLib.h> > > > > +#include <Library/PcdLib.h> > > > > +#include <Library/UefiLib.h> > > > > + > > > > +#include "NorFlash.h" > > > > + > > > > +STATIC > > > > +UINT32 > > > > +NorFlashReadStatusRegister ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN SR_Address > > > > + ) > > > > +{ > > > > + // Prepare to read the status register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER); > > > > + return MmioRead32 (Instance->DeviceBaseAddress); > > > > +} > > > > + > > > > +STATIC > > > > +BOOLEAN > > > > +NorFlashBlockIsLocked ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + UINT32 LockStatus; > > > > + > > > > + // Send command for reading device id > > > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > > > + > > > > + // Read block lock status > > > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > > > + > > > > + // Decode block lock status > > > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > > > + > > > > + if ((LockStatus & 0x2) != 0) { > > > > + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n")); > > > > + } > > > > + > > > > + return ((LockStatus & 0x1) != 0); > > > > +} > > > > + > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashUnlockSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + UINT32 LockStatus; > > > > + > > > > + // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations > > > > + // and to protect shared data structures. > > > > + > > > > + if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) { > > > > + do { > > > > + // Request a lock setup > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > > > + > > > > + // Request an unlock > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > > > + > > > > + // Send command for reading device id > > > > + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID); > > > > + > > > > + // Read block lock status > > > > + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)); > > > > + > > > > + // Decode block lock status > > > > + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus); > > > > + } while ((LockStatus & 0x1) == 1); > > > > + } else { > > > > + // Request a lock setup > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP); > > > > + > > > > + // Request an unlock > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK); > > > > + > > > > + // Wait until the status register gives us the all clear > > > > + do { > > > > + LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress); > > > > + } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > > + } > > > > + > > > > + // Put device back into Read Array mode > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress)); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashUnlockSingleBlockIfNecessary ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) { > > > > + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress); > > > > + } > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + * The following function presumes that the block has already been unlocked. > > > > + **/ > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashEraseSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINT32 StatusRegister; > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + // Request a block erase and then confirm it > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP); > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM); > > > > + > > > > + // Wait until the status register gives us the all clear > > > > + do { > > > > + StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress); > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > > + > > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == > > > > + (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", > > > > + BlockAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_ERASE) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", > > > > + BlockAddress, StatusRegister)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > > + // The debug level message has been reduced because a device > > > > + // lock might happen. In this case we just retry it ... > > > > + DEBUG ((DEBUG_INFO, > > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", > > > > + BlockAddress)); > > > > + Status = EFI_WRITE_PROTECTED; > > > > + } > > > > + > > > > + if (EFI_ERROR (Status)) { > > > > + // Clear the Status Register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > > + } > > > > + > > > > + // Put device back into Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + * This function unlock and erase an entire NOR Flash block. > > > > + **/ > > > > +EFI_STATUS > > > > +NorFlashUnlockAndEraseSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINTN Index; > > > > + NOR_FLASH_LOCK_CONTEXT Lock; > > > > + > > > > + NorFlashLock (&Lock); > > > > + > > > > + Index = 0; > > > > + // The block erase might fail a first time (SW bug ?). Retry it ... > > > > + do { > > > > + // Unlock the block if we have to > > > > + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > > > + if (EFI_ERROR (Status)) { > > > > + break; > > > > + } > > > > + Status = NorFlashEraseSingleBlock (Instance, BlockAddress); > > > > + Index++; > > > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED)); > > > > + > > > > + if (Index == NOR_FLASH_ERASE_RETRY) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", > > > > + BlockAddress,Index)); > > > > + } > > > > + > > > > + NorFlashUnlock (&Lock); > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashWriteSingleWord ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN WordAddress, > > > > + IN UINT32 WriteData > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINT32 StatusRegister; > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + // Request a write single word command > > > > + SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP); > > > > + > > > > + // Store the word into NOR Flash; > > > > + MmioWrite32 (WordAddress, WriteData); > > > > + > > > > + // Wait for the write to complete and then check for any errors; > > > > + // i.e. check the Status Register > > > > + do { > > > > + // Prepare to read the status register > > > > + StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress); > > > > + // The chip is busy while the WRITE bit is not asserted > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > > + > > > > + > > > > + // Perform a full status check: > > > > + // Mask the relevant bits of Status Register. > > > > + // Everything should be zero, if not, we have a problem > > > > + > > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", > > > > + WordAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", > > > > + WordAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", > > > > + WordAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (!EFI_ERROR (Status)) { > > > > + // Clear the Status Register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, > > > > + 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > > + } > > > > + > > > > + // Put device back into Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/* > > > > + * Writes data to the NOR Flash using the Buffered Programming method. > > > > + * > > > > + * The maximum size of the on-chip buffer is 32-words, because of hardware > > > > + * restrictions. Therefore this function will only handle buffers up to 32 > > > > + * words or 128 bytes. To deal with larger buffers, call this function again. > > > > + * > > > > + * This function presumes that both the TargetAddress and the > > > > + * TargetAddress+BufferSize exist entirely within the NOR Flash. > > > > + * Therefore these conditions will not be checked here. > > > > + * > > > > + * In buffered programming, if the target address not at the beginning of a > > > > + * 32-bit word boundary,then programming time is doubled and power consumption > > > > + * is increased. Therefore, it is a requirement to align buffer writes to > > > > + * 32-bit word boundaries. > > > > + * i.e. the last 4 bits of the target start address must be zero: 0x......00 > > > > + */ > > > > +EFI_STATUS > > > > +NorFlashWriteBuffer ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN TargetAddress, > > > > + IN UINTN BufferSizeInBytes, > > > > + IN UINT32 *Buffer > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINTN BufferSizeInWords; > > > > + UINTN Count; > > > > + volatile UINT32 *Data; > > > > + UINTN WaitForBuffer; > > > > + BOOLEAN BufferAvailable; > > > > + UINT32 StatusRegister; > > > > + > > > > + WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS; > > > > + BufferAvailable = FALSE; > > > > + > > > > + // Check that the target address does not cross a 32-word boundary. > > > > + if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Check there are some data to program > > > > + if (BufferSizeInBytes == 0) { > > > > + return EFI_BUFFER_TOO_SMALL; > > > > + } > > > > + > > > > + // Check that the buffer size does not exceed the maximum hardware buffer > > > > + // size on chip. > > > > + if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Check that the buffer size is a multiple of 32-bit words > > > > + if ((BufferSizeInBytes % 4) != 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Pre-programming conditions checked, now start the algorithm. > > > > + > > > > + // Prepare the data destination address > > > > + Data = (UINT32 *)TargetAddress; > > > > + > > > > + // Check the availability of the buffer > > > > + do { > > > > + // Issue the Buffered Program Setup command > > > > + SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP); > > > > + > > > > + // Read back the status register bit#7 from the same address > > > > + if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) { > > > > + BufferAvailable = TRUE; > > > > + } > > > > + > > > > + // Update the loop counter > > > > + WaitForBuffer--; > > > > + > > > > + } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE)); > > > > + > > > > + // The buffer was not available for writing > > > > + if (WaitForBuffer == 0) { > > > > + Status = EFI_DEVICE_ERROR; > > > > + goto EXIT; > > > > + } > > > > + > > > > + // From now on we work in 32-bit words > > > > + BufferSizeInWords = BufferSizeInBytes / (UINTN)4; > > > > + > > > > + // Write the word count, which is (buffer_size_in_words - 1), > > > > + // because word count 0 means one word. > > > > + SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1)); > > > > + > > > > + // Write the data to the NOR Flash, advancing each address by 4 bytes > > > > + for (Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) { > > > > + MmioWrite32 ((UINTN)Data, *Buffer); > > > > + } > > > > + > > > > + // Issue the Buffered Program Confirm command, to start the programming operation > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM); > > > > + > > > > + // Wait for the write to complete and then check for any errors; > > > > + // i.e. check the Status Register > > > > + do { > > > > + StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress); > > > > + // The chip is busy while the WRITE bit is not asserted > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE); > > > > + > > > > + > > > > + // Perform a full status check: > > > > + // Mask the relevant bits of Status Register. > > > > + // Everything should be zero, if not, we have a problem > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): VPP Range Error\n", > > > > + TargetAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Program Error\n", > > > > + TargetAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X): Device Protect Error\n", > > > > + TargetAddress)); > > > > + Status = EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (!EFI_ERROR (Status)) { > > > > + // Clear the Status Register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER); > > > > + } > > > > + > > > > +EXIT: > > > > + // Put device back into Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashWriteFullBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINT32 *DataBuffer, > > > > + IN UINT32 BlockSizeInWords > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINTN WordAddress; > > > > + UINT32 WordIndex; > > > > + UINTN BufferIndex; > > > > + UINTN BlockAddress; > > > > + UINTN BuffersInBlock; > > > > + UINTN RemainingWords; > > > > + UINTN Cnt; > > > > + NOR_FLASH_LOCK_CONTEXT Lock; > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + // Get the physical address of the block > > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4); > > > > + > > > > + // Start writing from the first address at the start of the block > > > > + WordAddress = BlockAddress; > > > > + > > > > + NorFlashLock (&Lock); > > > > + > > > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", > > > > + BlockAddress)); > > > > + goto EXIT; > > > > + } > > > > + > > > > + // To speed up the programming operation, NOR Flash is programmed using the > > > > + // Buffered Programming method. > > > > + > > > > + // Check that the address starts at a 32-word boundary, > > > > + // i.e. last 7 bits must be zero > > > > + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) { > > > > + > > > > + // First, break the entire block into buffer-sized chunks. > > > > + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES; > > > > + > > > > + // Then feed each buffer chunk to the NOR Flash > > > > + // If a buffer does not contain any data, don't write it. > > > > + for (BufferIndex=0; > > > > + BufferIndex < BuffersInBlock; > > > > + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, > > > > + DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS > > > > + ) { > > > > + // Check the buffer to see if it contains any data (not set all 1s). > > > > + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) { > > > > + if (~DataBuffer[Cnt] != 0 ) { > > > > + // Some data found, write the buffer. > > > > + Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, > > > > + DataBuffer); > > > > + if (EFI_ERROR (Status)) { > > > > + goto EXIT; > > > > + } > > > > + break; > > > > + } > > > > + } > > > > + } > > > > + > > > > + // Finally, finish off any remaining words that are less than the > > > > + // maximum size of the buffer > > > > + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS; > > > > + > > > > + if (RemainingWords != 0) { > > > > + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer); > > > > + if (EFI_ERROR (Status)) { > > > > + goto EXIT; > > > > + } > > > > + } > > > > + > > > > + } else { > > > > + // For now, use the single word programming algorithm > > > > + // It is unlikely that the NOR Flash will exist in an address which falls > > > > + // within a 32 word boundary range, > > > > + // i.e. which ends in the range 0x......01 - 0x......7F. > > > > + for (WordIndex=0; > > > > + WordIndex<BlockSizeInWords; > > > > + WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) { > > > > + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer); > > > > + if (EFI_ERROR (Status)) { > > > > + goto EXIT; > > > > + } > > > > + } > > > > + } > > > > + > > > > +EXIT: > > > > + NorFlashUnlock (&Lock); > > > > + > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", > > > > + WordAddress, Status)); > > > > + } > > > > + return Status; > > > > +} > > > > + > > > > +EFI_STATUS > > > > +NorFlashWriteBlocks ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN BufferSizeInBytes, > > > > + IN VOID *Buffer > > > > + ) > > > > +{ > > > > + UINT32 *pWriteBuffer; > > > > + EFI_STATUS Status = EFI_SUCCESS; > > > > + EFI_LBA CurrentBlock; > > > > + UINT32 BlockSizeInWords; > > > > + UINT32 NumBlocks; > > > > + UINT32 BlockCount; > > > > + > > > > + // The buffer must be valid > > > > + if (Buffer == NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // We must have some bytes to read > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes)); > > > > + if (BufferSizeInBytes == 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // The size of the buffer must be a multiple of the block size > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->BlockSize)); > > > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // All blocks must be within the device > > > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", > > > > + NumBlocks, Instance->LastBlock, Lba)); > > > > + > > > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n")); > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + BlockSizeInWords = Instance->BlockSize / 4; > > > > + > > > > + // Because the target *Buffer is a pointer to VOID, we must put all the > > > > + // data into a pointer to a proper data type, so use *ReadBuffer > > > > + pWriteBuffer = (UINT32 *)Buffer; > > > > + > > > > + CurrentBlock = Lba; > > > > + for (BlockCount=0; > > > > + BlockCount < NumBlocks; > > > > + BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) { > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock)); > > > > + > > > > + Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords); > > > > + > > > > + if (EFI_ERROR (Status)) { > > > > + break; > > > > + } > > > > + } > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status)); > > > > + return Status; > > > > +} > > > > + > > > > +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0) > > > > + > > > > +/** > > > > + Copy Length bytes from Source to Destination, using aligned accesses only. > > > > + Note that this implementation uses memcpy() semantics rather then memmove() > > > > + semantics, i.e., SourceBuffer and DestinationBuffer should not overlap. > > > > + > > > > + @param DestinationBuffer The target of the copy request. > > > > + @param SourceBuffer The place to copy from. > > > > + @param Length The number of bytes to copy. > > > > + > > > > + @return Destination > > > > + > > > > +**/ > > > > +STATIC > > > > +VOID * > > > > +AlignedCopyMem ( > > > > + OUT VOID *DestinationBuffer, > > > > + IN CONST VOID *SourceBuffer, > > > > + IN UINTN Length > > > > + ) > > > > +{ > > > > + UINT8 *Destination8; > > > > + CONST UINT8 *Source8; > > > > + UINT32 *Destination32; > > > > + CONST UINT32 *Source32; > > > > + UINT64 *Destination64; > > > > + CONST UINT64 *Source64; > > > > + > > > > + if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && Length >= 8) { > > > > + Destination64 = DestinationBuffer; > > > > + Source64 = SourceBuffer; > > > > + while (Length >= 8) { > > > > + *Destination64++ = *Source64++; > > > > + Length -= 8; > > > > + } > > > > + > > > > + Destination8 = (UINT8 *)Destination64; > > > > + Source8 = (CONST UINT8 *)Source64; > > > > + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && Length >= 4) { > > > > + Destination32 = DestinationBuffer; > > > > + Source32 = SourceBuffer; > > > > + while (Length >= 4) { > > > > + *Destination32++ = *Source32++; > > > > + Length -= 4; > > > > + } > > > > + > > > > + Destination8 = (UINT8 *)Destination32; > > > > + Source8 = (CONST UINT8 *)Source32; > > > > + } else { > > > > + Destination8 = DestinationBuffer; > > > > + Source8 = SourceBuffer; > > > > + } > > > > + while (Length-- != 0) { > > > > + *Destination8++ = *Source8++; > > > > + } > > > > + return DestinationBuffer; > > > > +} > > > > + > > > > +EFI_STATUS > > > > +NorFlashReadBlocks ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN BufferSizeInBytes, > > > > + OUT VOID *Buffer > > > > + ) > > > > +{ > > > > + UINT32 NumBlocks; > > > > + UINTN StartAddress; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n", > > > > + BufferSizeInBytes, Instance->BlockSize, Instance->LastBlock, Lba)); > > > > + > > > > + // The buffer must be valid > > > > + if (Buffer == NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Return if we have not any byte to read > > > > + if (BufferSizeInBytes == 0) { > > > > + return EFI_SUCCESS; > > > > + } > > > > + > > > > + // The size of the buffer must be a multiple of the block size > > > > + if ((BufferSizeInBytes % Instance->BlockSize) != 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // All blocks must be within the device > > > > + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->BlockSize ; > > > > + > > > > + if ((Lba + NumBlocks) > (Instance->LastBlock + 1)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashReadBlocks: ERROR - Read will exceed last block\n")); > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Get the address to start reading from > > > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > > + Lba, > > > > + Instance->BlockSize > > > > + ); > > > > + > > > > + // Put the device into Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + // Readout the data > > > > + AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +EFI_STATUS > > > > +NorFlashRead ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN UINTN BufferSizeInBytes, > > > > + OUT VOID *Buffer > > > > + ) > > > > +{ > > > > + UINTN StartAddress; > > > > + > > > > + // The buffer must be valid > > > > + if (Buffer == NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Return if we have not any byte to read > > > > + if (BufferSizeInBytes == 0) { > > > > + return EFI_SUCCESS; > > > > + } > > > > + > > > > + if (((Lba * Instance->BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) { > > > > + DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n")); > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Get the address to start reading from > > > > + StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > > + Lba, > > > > + Instance->BlockSize > > > > + ); > > > > + > > > > + // Put the device into Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + // Readout the data > > > > + AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/* > > > > + Write a full or portion of a block. It must not span block boundaries; > > > > + that is, Offset + *NumBytes <= Instance->Media.BlockSize. > > > > +*/ > > > > +EFI_STATUS > > > > +NorFlashWriteSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN UINT8 *Buffer > > > > + ) > > > > +{ > > > > + EFI_STATUS TempStatus; > > > > + UINT32 Tmp; > > > > + UINT32 TmpBuf; > > > > + UINT32 WordToWrite; > > > > + UINT32 Mask; > > > > + BOOLEAN DoErase; > > > > + UINTN BytesToWrite; > > > > + UINTN CurOffset; > > > > + UINTN WordAddr; > > > > + UINTN BlockSize; > > > > + UINTN BlockAddress; > > > > + UINTN PrevBlockAddress; > > > > + > > > > + PrevBlockAddress = 0; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > > > + Lba, Offset, *NumBytes, Buffer)); > > > > + > > > > + // Cache the block size to avoid de-referencing pointers all the time > > > > + BlockSize = Instance->BlockSize; > > > > + > > > > + // The write must not span block boundaries. > > > > + // We need to check each variable individually because adding two > > > > + // large values together overflows. > > > > + if ( ( Offset >= BlockSize ) || > > > > + ( *NumBytes > BlockSize ) || > > > > + ( (Offset + *NumBytes) > BlockSize ) ) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // We must have some bytes to write > > > > + if (*NumBytes == 0) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > > + (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Pick 128bytes as a good start for word operations as opposed to erasing the > > > > + // block and writing the data regardless if an erase is really needed. > > > > + // It looks like most individual NV variable writes are smaller than 128bytes. > > > > + if (*NumBytes <= 128) { > > > > + // Check to see if we need to erase before programming the data into NOR. > > > > + // If the destination bits are only changing from 1s to 0s we can just write. > > > > + // After a block is erased all bits in the block is set to 1. > > > > + // If any byte requires us to erase we just give up and rewrite all of it. > > > > + DoErase = FALSE; > > > > + BytesToWrite = *NumBytes; > > > > + CurOffset = Offset; > > > > + > > > > + while (BytesToWrite > 0) { > > > > + // Read full word from NOR, splice as required. A word is the smallest > > > > + // unit we can write. > > > > + TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + // Physical address of word in NOR to write. > > > > + WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, > > > > + Lba, BlockSize); > > > > + // The word of data that is to be written. > > > > + TmpBuf = *((UINT32*)(Buffer + (*NumBytes - BytesToWrite))); > > > > + > > > > + // First do word aligned chunks. > > > > + if ((CurOffset & 0x3) == 0) { > > > > + if (BytesToWrite >= 4) { > > > > + // Is the destination still in 'erased' state? > > > > + if (~Tmp != 0) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase = TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Write this word to NOR > > > > + WordToWrite = TmpBuf; > > > > + CurOffset += sizeof (TmpBuf); > > > > + BytesToWrite -= sizeof (TmpBuf); > > > > + } else { > > > > + // BytesToWrite < 4. Do small writes and left-overs > > > > + Mask = ~((~0) << (BytesToWrite * 8)); > > > > + // Mask out the bytes we want. > > > > + TmpBuf &= Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) != Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase = TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > > + CurOffset += BytesToWrite; > > > > + BytesToWrite = 0; > > > > + } > > > > + } else { > > > > + // Do multiple words, but starting unaligned. > > > > + if (BytesToWrite > (4 - (CurOffset & 0x3))) { > > > > + Mask = ((~0) << ((CurOffset & 0x3) * 8)); > > > > + // Mask out the bytes we want. > > > > + TmpBuf &= Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) != Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase = TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > > + BytesToWrite -= (4 - (CurOffset & 0x3)); > > > > + CurOffset += (4 - (CurOffset & 0x3)); > > > > + } else { > > > > + // Unaligned and fits in one word. > > > > + Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8); > > > > + // Mask out the bytes we want. > > > > + TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) != Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase = TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite = (Tmp & ~Mask) | TmpBuf; > > > > + CurOffset += BytesToWrite; > > > > + BytesToWrite = 0; > > > > + } > > > > + } > > > > + > > > > + // > > > > + // Write the word to NOR. > > > > + // > > > > + > > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize); > > > > + if (BlockAddress != PrevBlockAddress) { > > > > + TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + PrevBlockAddress = BlockAddress; > > > > + } > > > > + TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + } > > > > + // Exit if we got here and could write all the data. Otherwise do the > > > > + // Erase-Write cycle. > > > > + if (!DoErase) { > > > > + return EFI_SUCCESS; > > > > + } > > > > + } > > > > + > > > > + // Check we did get some memory. Buffer is BlockSize. > > > > + if (Instance->ShadowBuffer == NULL) { > > > > + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n")); > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + // Read NOR Flash data into shadow buffer > > > > + TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + // Return one of the pre-approved error statuses > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + // Put the data at the appropriate location inside the buffer area > > > > + CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes); > > > > + > > > > + // Write the modified buffer back to the NorFlash > > > > + TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + // Return one of the pre-approved error statuses > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +EFI_STATUS > > > > +NorFlashReset ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ) > > > > +{ > > > > + // As there is no specific RESET to perform, ensure that the devices > > > > + // is in the default Read Array mode > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY); > > > > + return EFI_SUCCESS; > > > > +} > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > > > new file mode 100644 > > > > index 0000000..0396f7a > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlash.h > > > > @@ -0,0 +1,326 @@ > > > > +/** @file NorFlash.h > > > > + > > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > > + > > > > + This program and the accompanying materials > > > > + are licensed and made available under the terms and conditions of the BSD > > > > + License which accompanies this distribution. The full text of the license > > > > + may be found at http://opensource.org/licenses/bsd-license.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > > + > > > > +**/ > > > > + > > > > +#ifndef __NOR_FLASH_H__ > > > > +#define __NOR_FLASH_H__ > > > > + > > > > +#include <Base.h> > > > > +#include <Guid/EventGroup.h> > > > > +#include <Library/DebugLib.h> > > > > +#include <Library/IoLib.h> > > > > +#include <Library/MmServicesTableLib.h> > > > > +#include <Library/NorFlashPlatformLib.h> > > > > +#include <Library/UefiLib.h> > > > > +#include <Library/UefiRuntimeLib.h> > > > > +#include <Protocol/FirmwareVolumeBlock.h> > > > > + > > > > +#define NOR_FLASH_ERASE_RETRY 10 > > > > + > > > > +// Device access macros > > > > +// These are necessary because we use 2 x 16bit parts to make up 32bit data > > > > + > > > > +#define HIGH_16_BITS 0xFFFF0000 > > > > +#define LOW_16_BITS 0x0000FFFF > > > > +#define LOW_8_BITS 0x000000FF > > > > + > > > > +#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | \ > > > > + ( value & LOW_16_BITS ) ) > > > > + > > > > +#define GET_LOW_BYTE(value) ( value & LOW_8_BITS ) > > > > +#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE ( value >> 16 ) ) > > > > + > > > > +// Each command must be sent simultaneously to both chips, > > > > +// i.e. at the lower 16 bits AND at the higher 16 bits > > > > +#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr) ( ( BaseAddr ) + \ > > > > + ( ( OffsetAddr ) << 2)) > > > > +#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16 ) | \ > > > > + ( Cmd & LOW_16_BITS ) ) > > > > +#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 \ > > > > + ( CREATE_NOR_ADDRESS ( BaseAddr,Offset ), \ > > > > + CREATE_DUAL_CMD ( Cmd) ) > > > > +#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + \ > > > > + ( UINTN )( ( Lba ) * LbaSize ) ) > > > > + > > > > +// Status Register Bits > > > > +#define P30_SR_BIT_WRITE ( BIT7 << 16 | BIT7 ) > > > > +#define P30_SR_BIT_ERASE_SUSPEND ( BIT6 << 16 | BIT6 ) > > > > +#define P30_SR_BIT_ERASE ( BIT5 << 16 | BIT5 ) > > > > +#define P30_SR_BIT_PROGRAM ( BIT4 << 16 | BIT4 ) > > > > +#define P30_SR_BIT_VPP ( BIT3 << 16 | BIT3 ) > > > > +#define P30_SR_BIT_PROGRAM_SUSPEND ( BIT2 << 16 | BIT2 ) > > > > +#define P30_SR_BIT_BLOCK_LOCKED ( BIT1 << 16 | BIT1 ) > > > > +#define P30_SR_BIT_BEFP ( BIT0 << 16 | BIT0 ) > > > > + > > > > +// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family > > > > + > > > > +// On chip buffer size for buffered programming operations > > > > +// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each > > > > +// word is 2 bytes. > > > > +// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes > > > > +#define P30_MAX_BUFFER_SIZE_IN_BYTES ( ( UINTN ) 128 ) > > > > +#define P30_MAX_BUFFER_SIZE_IN_WORDS ( P30_MAX_BUFFER_SIZE_IN_BYTES/ ( ( UINTN) 4 ) ) > > > > +#define MAX_BUFFERED_PROG_ITERATIONS 10000000 > > > > +#define BOUNDARY_OF_32_WORDS 0x7F > > > > + > > > > +// CFI Addresses > > > > +#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10 > > > > +#define P30_CFI_ADDR_VENDOR_ID 0x13 > > > > + > > > > +// CFI Data > > > > +#define CFI_QRY 0x00595251 > > > > + > > > > +// READ Commands > > > > +#define P30_CMD_READ_DEVICE_ID 0x0090 > > > > +#define P30_CMD_READ_STATUS_REGISTER 0x0070 > > > > +#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050 > > > > +#define P30_CMD_READ_ARRAY 0x00FF > > > > +#define P30_CMD_READ_CFI_QUERY 0x0098 > > > > + > > > > +// WRITE Commands > > > > +#define P30_CMD_WORD_PROGRAM_SETUP 0x0040 > > > > +#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010 > > > > +#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8 > > > > +#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0 > > > > +#define P30_CMD_BEFP_SETUP 0x0080 > > > > +#define P30_CMD_BEFP_CONFIRM 0x00D0 > > > > + > > > > +// ERASE Commands > > > > +#define P30_CMD_BLOCK_ERASE_SETUP 0x0020 > > > > +#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0 > > > > + > > > > +// SUSPEND Commands > > > > +#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0 > > > > +#define P30_CMD_SUSPEND_RESUME 0x00D0 > > > > + > > > > +// BLOCK LOCKING / UNLOCKING Commands > > > > +#define P30_CMD_LOCK_BLOCK_SETUP 0x0060 > > > > +#define P30_CMD_LOCK_BLOCK 0x0001 > > > > +#define P30_CMD_UNLOCK_BLOCK 0x00D0 > > > > +#define P30_CMD_LOCK_DOWN_BLOCK 0x002F > > > > + > > > > +// PROTECTION Commands > > > > +#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0 > > > > + > > > > +// CONFIGURATION Commands > > > > +#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060 > > > > +#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003 > > > > + > > > > +#define NOR_FLASH_SIGNATURE SIGNATURE_32 ('n', 'o', 'r', '0') > > > > +#define INSTANCE_FROM_FVB_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > > + FvbProtocol, \ > > > > + NOR_FLASH_SIGNATURE) > > > > +#define INSTANCE_FROM_BLKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > > + BlockIoProtocol, \ > > > > + NOR_FLASH_SIGNATURE) > > > > +#define INSTANCE_FROM_DISKIO_THIS(a) CR (a, NOR_FLASH_INSTANCE, \ > > > > + DiskIoProtocol, \ > > > > + NOR_FLASH_SIGNATURE) > > > > + > > > > +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE; > > > > +extern UINTN mFlashNvStorageVariableBase; > > > > + > > > > +#pragma pack (1) > > > > +typedef struct { > > > > + VENDOR_DEVICE_PATH Vendor; > > > > + UINT8 Index; > > > > + EFI_DEVICE_PATH_PROTOCOL End; > > > > +} NOR_FLASH_DEVICE_PATH; > > > > +#pragma pack () > > > > + > > > > +struct _NOR_FLASH_INSTANCE { > > > > + UINT32 Signature; > > > > + EFI_HANDLE Handle; > > > > + > > > > + UINTN DeviceBaseAddress; > > > > + UINTN RegionBaseAddress; > > > > + UINTN Size; > > > > + UINT32 BlockSize; > > > > + UINT32 LastBlock; > > > > + EFI_LBA StartLba; > > > > + > > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol; > > > > + VOID* ShadowBuffer; > > > > + > > > > + NOR_FLASH_DEVICE_PATH DevicePath; > > > > +}; > > > > + > > > > +EFI_STATUS > > > > +NorFlashWriteBuffer ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN TargetAddress, > > > > + IN UINTN BufferSizeInBytes, > > > > + IN UINT32 *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashCreateInstance ( > > > > + IN UINTN NorFlashDeviceBase, > > > > + IN UINTN NorFlashRegionBase, > > > > + IN UINTN NorFlashSize, > > > > + IN UINT32 Index, > > > > + IN UINT32 BlockSize, > > > > + IN BOOLEAN SupportFvb, > > > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +NorFlashFvbInitialize ( > > > > + IN NOR_FLASH_INSTANCE* Instance > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +ValidateFvHeader ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +InitializeFvAndVariableStoreHeaders ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +NorFlashFvbInitialize ( > > > > + IN NOR_FLASH_INSTANCE* Instance > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetAttributes ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbSetAttributes ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetPhysicalAddress ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + OUT EFI_PHYSICAL_ADDRESS *Address > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetBlockSize ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + OUT UINTN *BlockSize, > > > > + OUT UINTN *NumberOfBlocks > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbRead ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN OUT UINT8 *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbWrite ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN UINT8 *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbEraseBlocks ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + ... > > > > + ); > > > > + > > > > +typedef struct { > > > > + EFI_TPL OriginalTPL; > > > > +} NOR_FLASH_LOCK_CONTEXT; > > > > + > > > > +VOID > > > > +EFIAPI > > > > +NorFlashLock ( > > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > > + ); > > > > + > > > > +VOID > > > > +EFIAPI > > > > +NorFlashUnlock ( > > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashUnlockAndEraseSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashWriteSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN UINT8 *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashWriteBlocks ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN BufferSizeInBytes, > > > > + IN VOID *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashReadBlocks ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN BufferSizeInBytes, > > > > + OUT VOID *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashRead ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN UINTN BufferSizeInBytes, > > > > + OUT VOID *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashWrite ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN UINT8 *Buffer > > > > + ); > > > > + > > > > +EFI_STATUS > > > > +NorFlashReset ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ); > > > > + > > > > +#endif /* __NOR_FLASH_H__ */ > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > > > new file mode 100644 > > > > index 0000000..6ad3769 > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashFvb.c > > > > @@ -0,0 +1,740 @@ > > > > +/*++ @file NorFlashFvb.c > > > > + > > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > > + > > > > + This program and the accompanying materials > > > > + are licensed and made available under the terms and conditions of the > > > > + BSD License which accompanies this distribution. The full text of the > > > > + license may be found at http://opensource.org/licenses/bsd-license.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > > + > > > > + --*/ > > > > + > > > > +#include <Guid/VariableFormat.h> > > > > +#include <Library/BaseMemoryLib.h> > > > > +#include <Library/BaseLib.h> > > > > +#include <Library/MemoryAllocationLib.h> > > > > +#include <Library/PcdLib.h> > > > > +#include <Library/UefiLib.h> > > > > + > > > > +#include "NorFlash.h" > > > > + > > > > +UINTN mFlashNvStorageVariableBase; > > > > + > > > > +/// > > > > +/// The Firmware Volume Block Protocol is the low-level interface > > > > +/// to a firmware volume. File-level access to a firmware volume > > > > +/// should not be done using the Firmware Volume Block Protocol. > > > > +/// Normal access to a firmware volume must use the Firmware > > > > +/// Volume Protocol. Typically, only the file system driver that > > > > +/// produces the Firmware Volume Protocol will bind to the > > > > +/// Firmware Volume Block Protocol. > > > > +/// > > > > + > > > > +/** > > > > + Initialises the FV Header and Variable Store Header > > > > + to support variable operations. > > > > + > > > > + @param[in] Ptr - Location to initialise the headers > > > > + > > > > +**/ > > > > +EFI_STATUS > > > > +InitializeFvAndVariableStoreHeaders ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + VOID* Headers; > > > > + UINTN HeadersLength; > > > > + EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader; > > > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > > > + > > > > + HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + > > > > + sizeof (VARIABLE_STORE_HEADER); > > > > + Headers = AllocateZeroPool (HeadersLength); > > > > + > > > > + // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND > > > > + // the FTW working area AND the FTW Spare contiguous. > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) == > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingBase)); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) == > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareBase)); > > > > + > > > > + // Check if the size of the area is at least one block size > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageVariableSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageVariableSize) / Instance->BlockSize > 0)); > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwWorkingSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) / Instance->BlockSize > 0)); > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwSpareSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageFtwSpareSize) / Instance->BlockSize > 0)); > > > > + > > > > + // Ensure the Variable area Base Addresses are aligned on a > > > > + // block size boundaries > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) % Instance->BlockSize == 0); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) % Instance->BlockSize == 0); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwSpareBase) % Instance->BlockSize == 0); > > > > + > > > > + // > > > > + // EFI_FIRMWARE_VOLUME_HEADER > > > > + // > > > > + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers; > > > > + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid); > > > > + FirmwareVolumeHeader->FvLength = > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > > > + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE; > > > > + FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) ( > > > > + EFI_FVB2_READ_ENABLED_CAP | > > > > + // Reads may be enabled > > > > + EFI_FVB2_READ_STATUS | > > > > + // Reads are currently enabled > > > > + EFI_FVB2_STICKY_WRITE | > > > > + // A block erase is required to flip > > > > + // bits into EFI_FVB2_ERASE_POLARITY > > > > + EFI_FVB2_MEMORY_MAPPED | > > > > + // It is memory mapped > > > > + EFI_FVB2_ERASE_POLARITY | > > > > + // After erasure all bits take this > > > > + // value (i.e. '1') > > > > + EFI_FVB2_WRITE_STATUS | > > > > + // Writes are currently enabled > > > > + EFI_FVB2_WRITE_ENABLED_CAP > > > > + // Writes may be enabled > > > > + ); > > > > + FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY); > > > > + FirmwareVolumeHeader->Revision = EFI_FVH_REVISION; > > > > + FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->LastBlock + 1; > > > > + FirmwareVolumeHeader->BlockMap[0].Length = Instance->BlockSize; > > > > + FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0; > > > > + FirmwareVolumeHeader->BlockMap[1].Length = 0; > > > > + FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ( > > > > + (UINT16*)FirmwareVolumeHeader, > > > > + FirmwareVolumeHeader->HeaderLength); > > > > + > > > > + // > > > > + // VARIABLE_STORE_HEADER > > > > + // > > > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)Headers + > > > > + FirmwareVolumeHeader->HeaderLength); > > > > + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid); > > > > + VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - > > > > + FirmwareVolumeHeader->HeaderLength; > > > > + VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED; > > > > + VariableStoreHeader->State = VARIABLE_STORE_HEALTHY; > > > > + > > > > + // Install the combined super-header in the NorFlash > > > > + Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers); > > > > + > > > > + FreePool (Headers); > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + Check the integrity of firmware volume header. > > > > + > > > > + @param[in] FwVolHeader - A pointer to a firmware volume header > > > > + > > > > + @retval EFI_SUCCESS - The firmware volume is consistent > > > > + @retval EFI_NOT_FOUND - The firmware volume has been corrupted. > > > > + > > > > +**/ > > > > +EFI_STATUS > > > > +ValidateFvHeader ( > > > > + IN NOR_FLASH_INSTANCE *Instance > > > > + ) > > > > +{ > > > > + UINT16 Checksum; > > > > + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; > > > > + VARIABLE_STORE_HEADER *VariableStoreHeader; > > > > + UINTN VariableStoreLength; > > > > + UINTN FvLength; > > > > + > > > > + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress; > > > > + > > > > + FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > > > + > > > > + // > > > > + // Verify the header revision, header signature, length > > > > + // Length of FvBlock cannot be 2**64-1 > > > > + // HeaderLength cannot be an odd number > > > > + // > > > > + if ( (FwVolHeader->Revision != EFI_FVH_REVISION) > > > > + || (FwVolHeader->Signature != EFI_FVH_SIGNATURE) > > > > + || (FwVolHeader->FvLength != FvLength) > > > > + ) > > > > + { > > > > + DEBUG ((DEBUG_INFO, "%a: No Firmware Volume header present\n", > > > > + __FUNCTION__)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + // Check the Firmware Volume Guid > > > > + if (CompareGuid (&FwVolHeader->FileSystemGuid, > > > > + &gEfiSystemNvDataFvGuid) == FALSE ) { > > > > + DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\n", > > > > + __FUNCTION__)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + // Verify the header checksum > > > > + Checksum = CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader->HeaderLength); > > > > + if (Checksum != 0) { > > > > + DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n", > > > > + __FUNCTION__, Checksum)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)FwVolHeader + > > > > + FwVolHeader->HeaderLength); > > > > + > > > > + // Check the Variable Store Guid > > > > + if (!CompareGuid (&VariableStoreHeader->Signature, > > > > + &gEfiVariableGuid) && > > > > + !CompareGuid (&VariableStoreHeader->Signature, > > > > + &gEfiAuthenticatedVariableGuid)) { > > > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Guid non-compatible\n", > > > > + __FUNCTION__)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - > > > > + FwVolHeader->HeaderLength; > > > > + if (VariableStoreHeader->Size != VariableStoreLength) { > > > > + DEBUG ((DEBUG_INFO, "%a: Variable Store Length does not match\n", > > > > + __FUNCTION__)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/** > > > > + The GetAttributes() function retrieves the attributes and > > > > + current settings of the block. > > > > + > > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > > + > > > > + @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and > > > > + current settings are returned. > > > > + Type EFI_FVB_ATTRIBUTES_2 is defined in > > > > + EFI_FIRMWARE_VOLUME_HEADER. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetAttributes ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > > + ) > > > > +{ > > > > + EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes; > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) ( > > > > + > > > > + EFI_FVB2_READ_ENABLED_CAP | > > > > + // Reads may be enabled > > > > + EFI_FVB2_READ_STATUS | > > > > + // Reads are currently enabled > > > > + EFI_FVB2_WRITE_ENABLED_CAP | > > > > + // Writes may be enabled > > > > + EFI_FVB2_WRITE_STATUS | > > > > + // Writes are currently enabled > > > > + EFI_FVB2_STICKY_WRITE | > > > > + // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY > > > > + EFI_FVB2_MEMORY_MAPPED | > > > > + // It is memory mapped > > > > + EFI_FVB2_ERASE_POLARITY > > > > + // After erasure all bits take this value (i.e. '1') > > > > + > > > > + ); > > > > + > > > > + *Attributes = FlashFvbAttributes; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes)); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/** > > > > + The SetAttributes() function sets configurable firmware volume attributes > > > > + and returns the new settings of the firmware volume. > > > > + > > > > + > > > > + @param This Indicates the > > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > > + > > > > + @param Attributes On input, Attributes is a pointer to > > > > + EFI_FVB_ATTRIBUTES_2 that contains the desired > > > > + firmware volume settings. On successful return, > > > > + it contains the new settings of the firmware > > > > + volume. Type EFI_FVB_ATTRIBUTES_2 is defined > > > > + in EFI_FIRMWARE_VOLUME_HEADER. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume attributes were returned. > > > > + > > > > + @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with > > > > + the capabilities > > > > + as declared in the firmware volume header. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbSetAttributes ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes > > > > + ) > > > > +{ > > > > + DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes)); > > > > + return EFI_UNSUPPORTED; > > > > +} > > > > + > > > > +/** > > > > + The GetPhysicalAddress() function retrieves the base address of > > > > + a memory-mapped firmware volume. This function should be called > > > > + only for memory-mapped firmware volumes. > > > > + > > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Address Pointer to a caller-allocated > > > > + EFI_PHYSICAL_ADDRESS that, on successful > > > > + return from GetPhysicalAddress(), contains the > > > > + base address of the firmware volume. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > > > + > > > > + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetPhysicalAddress ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + OUT EFI_PHYSICAL_ADDRESS *Address > > > > + ) > > > > +{ > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", > > > > + Instance->RegionBaseAddress)); > > > > + > > > > + ASSERT (Address != NULL); > > > > + > > > > + *Address = mFlashNvStorageVariableBase; > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/** > > > > + The GetBlockSize() function retrieves the size of the requested > > > > + block. It also returns the number of additional blocks with > > > > + the identical size. The GetBlockSize() function is used to > > > > + retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER). > > > > + > > > > + > > > > + @param This Indicates the > > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance. > > > > + > > > > + @param Lba Indicates the block for which to return > > > > + the size. > > > > + > > > > + @param BlockSize Pointer to a caller-allocated UINTN in which > > > > + the size of the block is returned. > > > > + > > > > + @param NumberOfBlocks Pointer to a caller-allocated UINTN in > > > > + which the number of consecutive blocks, > > > > + starting with Lba, is returned. All > > > > + blocks in this range have a size of > > > > + BlockSize. > > > > + > > > > + > > > > + @retval EFI_SUCCESS The firmware volume base address was returned. > > > > + > > > > + @retval EFI_INVALID_PARAMETER The requested LBA is out of range. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetBlockSize ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + OUT UINTN *BlockSize, > > > > + OUT UINTN *NumberOfBlocks > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", > > > > + Lba, Instance->BlockSize, Instance->LastBlock)); > > > > + > > > > + if (Lba > Instance->LastBlock) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", > > > > + Lba, Instance->LastBlock)); > > > > + Status = EFI_INVALID_PARAMETER; > > > > + } else { > > > > + // This is easy because in this platform each NorFlash device > > > > + // has equal sized blocks. > > > > + *BlockSize = (UINTN) Instance->BlockSize; > > > > + *NumberOfBlocks = (UINTN) (Instance->LastBlock - Lba + 1); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbGetBlockSize: *BlockSize=0x%x,*NumberOfBlocks=0x%x.\n", > > > > + *BlockSize, *NumberOfBlocks)); > > > > + > > > > + Status = EFI_SUCCESS; > > > > + } > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + Reads the specified number of bytes into a buffer from the specified block. > > > > + > > > > + The Read() function reads the requested number of bytes from the > > > > + requested block and stores them in the provided buffer. > > > > + Implementations should be mindful that the firmware volume > > > > + might be in the ReadDisabled state. If it is in this state, > > > > + the Read() function must return the status code > > > > + EFI_ACCESS_DENIED without modifying the contents of the > > > > + buffer. The Read() function must also prevent spanning block > > > > + boundaries. If a read is requested that would span a block > > > > + boundary, the read must read up to the boundary but not > > > > + beyond. The output parameter NumBytes must be set to correctly > > > > + indicate the number of bytes actually read. The caller must be > > > > + aware that a read may be partially completed. > > > > + > > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Lba The starting logical block index from which to read. > > > > + > > > > + @param Offset Offset into the block at which to begin reading. > > > > + > > > > + @param NumBytes Pointer to a UINTN. > > > > + At entry, *NumBytes contains the total size of the buffer. > > > > + At exit, *NumBytes contains the total number of bytes read. > > > > + > > > > + @param Buffer Pointer to a caller-allocated buffer that will be used > > > > + to hold the data that is read. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume was read successfully,and contents are > > > > + in Buffer. > > > > + > > > > + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary. > > > > + On output, NumBytes contains the total number of bytes > > > > + returned in Buffer. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state. > > > > + > > > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and > > > > + could not be read. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbRead ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN OUT UINT8 *Buffer > > > > + ) > > > > +{ > > > > + EFI_STATUS TempStatus; > > > > + UINTN BlockSize; > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", > > > > + Instance->StartLba + Lba, Offset, *NumBytes, Buffer)); > > > > + > > > > + TempStatus = EFI_SUCCESS; > > > > + > > > > + // Cache the block size to avoid de-referencing pointers all the time > > > > + BlockSize = Instance->BlockSize; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + > > > > + // The read must not span block boundaries. > > > > + // We need to check each variable individually because adding two > > > > + // large values together overflows. > > > > + if ((Offset >= BlockSize) || > > > > + (*NumBytes > BlockSize) || > > > > + ((Offset + *NumBytes) > BlockSize)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // We must have some bytes to read > > > > + if (*NumBytes == 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Decide if we are doing full block reads or not. > > > > + if (*NumBytes % BlockSize != 0) { > > > > + TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + } else { > > > > + // Read NOR Flash data into shadow buffer > > > > + TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + // Return one of the pre-approved error statuses > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + } > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/** > > > > + Writes the specified number of bytes from the input buffer to the block. > > > > + > > > > + The Write() function writes the specified number of bytes from > > > > + the provided buffer to the specified block and offset. If the > > > > + firmware volume is sticky write, the caller must ensure that > > > > + all the bits of the specified range to write are in the > > > > + EFI_FVB_ERASE_POLARITY state before calling the Write() > > > > + function, or else the result will be unpredictable. This > > > > + unpredictability arises because, for a sticky-write firmware > > > > + volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY > > > > + state but cannot flip it back again. Before calling the > > > > + Write() function, it is recommended for the caller to first call > > > > + the EraseBlocks() function to erase the specified block to > > > > + write. A block erase cycle will transition bits from the > > > > + (NOT)EFI_FVB_ERASE_POLARITY state back to the > > > > + EFI_FVB_ERASE_POLARITY state. Implementations should be > > > > + mindful that the firmware volume might be in the WriteDisabled > > > > + state. If it is in this state, the Write() function must > > > > + return the status code EFI_ACCESS_DENIED without modifying the > > > > + contents of the firmware volume. The Write() function must > > > > + also prevent spanning block boundaries. If a write is > > > > + requested that spans a block boundary, the write must store up > > > > + to the boundary but not beyond. The output parameter NumBytes > > > > + must be set to correctly indicate the number of bytes actually > > > > + written. The caller must be aware that a write may be > > > > + partially completed. All writes, partial or otherwise, must be > > > > + fully flushed to the hardware before the Write() service > > > > + returns. > > > > + > > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Lba The starting logical block index to write to. > > > > + > > > > + @param Offset Offset into the block at which to begin writing. > > > > + > > > > + @param NumBytes The pointer to a UINTN. > > > > + At entry, *NumBytes contains the total size of the > > > > + buffer. > > > > + At exit, *NumBytes contains the total number of > > > > + bytes actually written. > > > > + > > > > + @param Buffer The pointer to a caller-allocated buffer that contains > > > > + the source for the write. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume was written successfully. > > > > + > > > > + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary. > > > > + On output, NumBytes contains the total number of bytes > > > > + actually written. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > > > + > > > > + @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not > > > > + be written. > > > > + > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbWrite ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + IN EFI_LBA Lba, > > > > + IN UINTN Offset, > > > > + IN OUT UINTN *NumBytes, > > > > + IN UINT8 *Buffer > > > > + ) > > > > +{ > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer); > > > > +} > > > > + > > > > +/** > > > > + Erases and initialises a firmware volume block. > > > > + > > > > + The EraseBlocks() function erases one or more blocks as denoted > > > > + by the variable argument list. The entire parameter list of > > > > + blocks must be verified before erasing any blocks. If a block is > > > > + requested that does not exist within the associated firmware > > > > + volume (it has a larger index than the last block of the > > > > + firmware volume), the EraseBlocks() function must return the > > > > + status code EFI_INVALID_PARAMETER without modifying the contents > > > > + of the firmware volume. Implementations should be mindful that > > > > + the firmware volume might be in the WriteDisabled state. If it > > > > + is in this state, the EraseBlocks() function must return the > > > > + status code EFI_ACCESS_DENIED without modifying the contents of > > > > + the firmware volume. All calls to EraseBlocks() must be fully > > > > + flushed to the hardware before the EraseBlocks() service > > > > + returns. > > > > + > > > > + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param ... The variable argument list is a list of tuples. > > > > + Each tuple describes a range of LBAs to erase > > > > + and consists of the following: > > > > + - An EFI_LBA that indicates the starting LBA > > > > + - A UINTN that indicates the number of blocks > > > > + to erase. > > > > + > > > > + The list is terminated with an > > > > + EFI_LBA_LIST_TERMINATOR. > > > > + For example, the following indicates that two > > > > + ranges of blocks (5-7 and 10-11) are to be erased: > > > > + EraseBlocks (This, 5, 3, 10, 2, > > > > + EFI_LBA_LIST_TERMINATOR); > > > > + > > > > + @retval EFI_SUCCESS The erase request successfully completed. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state. > > > > + > > > > + @retval EFI_DEVICE_ERROR The block device is not functioning correctly > > > > + and could not be written. > > > > + The firmware device may have been partially erased. > > > > + > > > > + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable > > > > + argument list do not exist in the firmware volume. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbEraseBlocks ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + ... > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + VA_LIST Args; > > > > + UINTN BlockAddress; // Physical address of Lba to erase > > > > + EFI_LBA StartingLba; // Lba from which we start erasing > > > > + UINTN NumOfLba; // Number of Lba blocks to erase > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance = INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n")); > > > > + > > > > + Status = EFI_SUCCESS; > > > > + > > > > + // Before erasing, check the entire list of parameters to > > > > + // ensure all specified blocks are valid > > > > + > > > > + VA_START (Args, This); > > > > + do { > > > > + // Get the Lba from which we start erasing > > > > + StartingLba = VA_ARG (Args, EFI_LBA); > > > > + > > > > + // Have we reached the end of the list? > > > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > > > + //Exit the while loop > > > > + break; > > > > + } > > > > + > > > > + // How many Lba blocks are we requested to erase? > > > > + NumOfLba = VA_ARG (Args, UINTN); > > > > + > > > > + // All blocks must be within range > > > > + DEBUG (( > > > > + DEBUG_BLKIO, > > > > + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n", > > > > + Instance->StartLba + StartingLba, > > > > + (UINT64)NumOfLba, > > > > + Instance->LastBlock > > > > + )); > > > > + if ((NumOfLba == 0) || > > > > + ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->LastBlock)) { > > > > + VA_END (Args); > > > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n")); > > > > + Status = EFI_INVALID_PARAMETER; > > > > + goto EXIT; > > > > + } > > > > + } while (TRUE); > > > > + VA_END (Args); > > > > + > > > > + // > > > > + // To get here, all must be ok, so start erasing > > > > + // > > > > + VA_START (Args, This); > > > > + do { > > > > + // Get the Lba from which we start erasing > > > > + StartingLba = VA_ARG (Args, EFI_LBA); > > > > + > > > > + // Have we reached the end of the list? > > > > + if (StartingLba == EFI_LBA_LIST_TERMINATOR) { > > > > + // Exit the while loop > > > > + break; > > > > + } > > > > + > > > > + // How many Lba blocks are we requested to erase? > > > > + NumOfLba = VA_ARG (Args, UINTN); > > > > + > > > > + // Go through each one and erase it > > > > + while (NumOfLba > 0) { > > > > + > > > > + // Get the physical address of Lba to erase > > > > + BlockAddress = GET_NOR_BLOCK_ADDRESS ( > > > > + Instance->RegionBaseAddress, > > > > + Instance->StartLba + StartingLba, > > > > + Instance->BlockSize > > > > + ); > > > > + > > > > + // Erase it > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", > > > > + Instance->StartLba + StartingLba, BlockAddress)); > > > > + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress); > > > > + if (EFI_ERROR (Status)) { > > > > + VA_END (Args); > > > > + Status = EFI_DEVICE_ERROR; > > > > + goto EXIT; > > > > + } > > > > + > > > > + // Move to the next Lba > > > > + StartingLba++; > > > > + NumOfLba--; > > > > + } > > > > + } while (TRUE); > > > > + VA_END (Args); > > > > + > > > > +EXIT: > > > > + return Status; > > > > +} > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > > > new file mode 100644 > > > > index 0000000..08e20ae > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.c > > > > @@ -0,0 +1,250 @@ > > > > +/*++ @file NorFlashStandaloneMm.c > > > > + > > > > + Copyright (c) 2019, ARM Ltd. All rights reserved. > > > > + > > > > + This program and the accompanying materials > > > > + are licensed and made available under the terms and conditions of the BSD > > > > + License which accompanies this distribution. The full text of the license > > > > + may be found at http://opensource.org/licenses/bsd-license.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > > + > > > > + --*/ > > > > + > > > > +#include <PiMm.h> > > > > + > > > > +#include <Library/BaseLib.h> > > > > +#include <Library/BaseMemoryLib.h> > > > > +#include <Library/MemoryAllocationLib.h> > > > > +#include <Library/PcdLib.h> > > > > + > > > > +#include "NorFlash.h" > > > > + > > > > +// > > > > +// Global variable declarations > > > > +// > > > > +STATIC NOR_FLASH_INSTANCE **mNorFlashInstances; > > > > +STATIC UINT32 mNorFlashDeviceCount; > > > > + > > > > +STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = { > > > > + NOR_FLASH_SIGNATURE, // Signature > > > > + NULL, // Handle ... NEED TO BE FILLED > > > > + > > > > + 0, // DeviceBaseAddress ... NEED TO BE FILLED > > > > + 0, // RegionBaseAddress ... NEED TO BE FILLED > > > > + 0, // Size ... NEED TO BE FILLED > > > > + 0, // BlockSize ... NEED TO BE FILLED > > > > + 0, // LastBlock ... NEED TO BE FILLED > > > > + 0, // StartLba ... NEED TO BE FILLED > > > > + > > > > + { > > > > + FvbGetAttributes, // GetAttributes > > > > + FvbSetAttributes, // SetAttributes > > > > + FvbGetPhysicalAddress, // GetPhysicalAddress > > > > + FvbGetBlockSize, // GetBlockSize > > > > + FvbRead, // Read > > > > + FvbWrite, // Write > > > > + FvbEraseBlocks, // EraseBlocks > > > > + NULL, //ParentHandle > > > > + }, // FvbProtoccol; > > > > + NULL, // ShadowBuffer > > > > + { > > > > + { > > > > + { > > > > + HARDWARE_DEVICE_PATH, > > > > + HW_VENDOR_DP, > > > > + { > > > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)), > > > > + (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8) > > > > + } > > > > + }, > > > > + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, > > > > + // GUID ... NEED TO BE FILLED > > > > + }, > > > > + 0, // Index > > > > + { > > > > + END_DEVICE_PATH_TYPE, > > > > + END_ENTIRE_DEVICE_PATH_SUBTYPE, > > > > + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } > > > > + } > > > > + } // DevicePath > > > > +}; > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +NorFlashFvbInitialize ( > > > > + IN NOR_FLASH_INSTANCE* Instance > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINT32 FvbNumLba; > > > > + > > > > + DEBUG ((DEBUG_BLKIO,"NorFlashFvbInitialize\n")); > > > > + ASSERT ((Instance != NULL)); > > > > + > > > > + mFlashNvStorageVariableBase = FixedPcdGet32 (PcdFlashNvStorageVariableBase); > > > > + > > > > + // Set the index of the first LBA for the FVB > > > > + Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - > > > > + Instance->RegionBaseAddress) / Instance->BlockSize; > > > > + > > > > + // Determine if there is a valid header at the beginning of the NorFlash > > > > + Status = ValidateFvHeader (Instance); > > > > + > > > > + // Install the Default FVB header if required > > > > + if (EFI_ERROR (Status)) { > > > > + // There is no valid header, so time to install one. > > > > + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__)); > > > > + DEBUG ((DEBUG_INFO, "%a: Installing a correct one for this volume.\n", > > > > + __FUNCTION__)); > > > > + > > > > + // Erase all the NorFlash that is reserved for variable storage > > > > + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / > > > > + Instance->BlockSize; > > > > + > > > > + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, > > > > + EFI_LBA_LIST_TERMINATOR); > > > > + if (EFI_ERROR (Status)) { > > > > + return Status; > > > > + } > > > > + > > > > + // Install all appropriate headers > > > > + Status = InitializeFvAndVariableStoreHeaders (Instance); > > > > + if (EFI_ERROR (Status)) { > > > > + return Status; > > > > + } > > > > + } > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +VOID > > > > +EFIAPI > > > > +NorFlashLock ( > > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > > + ) > > > > +{ > > > > +} > > > > + > > > > +VOID > > > > +EFIAPI > > > > +NorFlashUnlock ( > > > > + NOR_FLASH_LOCK_CONTEXT *Context > > > > + ) > > > > +{ > > > > +} > > > > + > > > > +EFI_STATUS > > > > +NorFlashCreateInstance ( > > > > + IN UINTN NorFlashDeviceBase, > > > > + IN UINTN NorFlashRegionBase, > > > > + IN UINTN NorFlashSize, > > > > + IN UINT32 Index, > > > > + IN UINT32 BlockSize, > > > > + IN BOOLEAN SupportFvb, > > > > + OUT NOR_FLASH_INSTANCE** NorFlashInstance > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + NOR_FLASH_INSTANCE* Instance; > > > > + > > > > + ASSERT (NorFlashInstance != NULL); > > > > + > > > > + Instance = AllocateCopyPool (sizeof (NOR_FLASH_INSTANCE), > > > > + &mNorFlashInstanceTemplate); > > > > + if (Instance == NULL) { > > > > + return EFI_OUT_OF_RESOURCES; > > > > + } > > > > + > > > > + Instance->DeviceBaseAddress = NorFlashDeviceBase; > > > > + Instance->RegionBaseAddress = NorFlashRegionBase; > > > > + Instance->Size = NorFlashSize; > > > > + > > > > + Instance->BlockSize = BlockSize; > > > > + Instance->LastBlock = (NorFlashSize / BlockSize)-1; > > > > + > > > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid); > > > > + Instance->DevicePath.Index = (UINT8)Index; > > > > + > > > > + NorFlashReset (Instance); > > > > + > > > > + Instance->ShadowBuffer = AllocatePool (BlockSize);; > > > > + if (Instance->ShadowBuffer == NULL) { > > > > + return EFI_OUT_OF_RESOURCES; > > > > + } > > > > + > > > > + if (SupportFvb) { > > > > + NorFlashFvbInitialize (Instance); > > > > + > > > > + //Install FirmwareVolumeBlock Protocol > > > > + Status = gMmst->MmInstallProtocolInterface ( > > > > + &Instance->Handle, > > > > + &gEfiSmmFirmwareVolumeBlockProtocolGuid, > > > > + EFI_NATIVE_INTERFACE, > > > > + &Instance->FvbProtocol > > > > + ); > > > > + if (EFI_ERROR (Status)) { > > > > + FreePool (Instance); > > > > + return Status; > > > > + } > > > > + } > > > > + > > > > + *NorFlashInstance = Instance; > > > > + return Status; > > > > +} > > > > + > > > > +EFI_STATUS > > > > +EFIAPI > > > > +NorFlashInitialise ( > > > > + IN EFI_HANDLE ImageHandle, > > > > + IN EFI_MM_SYSTEM_TABLE *SystemTable > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINT32 Index; > > > > + NOR_FLASH_DESCRIPTION* NorFlashDevices; > > > > + BOOLEAN ContainVariableStorage; > > > > + > > > > + Status = NorFlashPlatformInitialization (); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashInitialise: Fail to initialize Nor Flash devices\n")); > > > > + return Status; > > > > + } > > > > + > > > > + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n")); > > > > + return Status; > > > > + } > > > > + > > > > + mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE*) * mNorFlashDeviceCount); > > > > + > > > > + for (Index = 0; Index < mNorFlashDeviceCount; Index++) { > > > > + // Check if this NOR Flash device contain the variable storage region > > > > + ContainVariableStorage = > > > > + (NorFlashDevices[Index].RegionBaseAddress <= > > > > + PcdGet32 (PcdFlashNvStorageVariableBase)) && > > > > + (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) <= > > > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size); > > > > + > > > > + Status = NorFlashCreateInstance ( > > > > + NorFlashDevices[Index].DeviceBaseAddress, > > > > + NorFlashDevices[Index].RegionBaseAddress, > > > > + NorFlashDevices[Index].Size, > > > > + Index, > > > > + NorFlashDevices[Index].BlockSize, > > > > + ContainVariableStorage, > > > > + &mNorFlashInstances[Index] > > > > + ); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index)); > > > > + } > > > > + } > > > > + return Status; > > > > +} > > > > diff --git a/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > > > new file mode 100644 > > > > index 0000000..12073fc > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneMm.inf > > > > @@ -0,0 +1,68 @@ > > > > +#/** @file > > > > +# > > > > +# Component description file for NorFlashStandaloneMm module > > > > +# > > > > +# Copyright (c) 2019, ARM Ltd. All rights reserved.<BR> > > > > +# > > > > +# This program and the accompanying materials > > > > +# are licensed and made available under the terms and conditions of the BSD License > > > > +# which accompanies this distribution. The full text of the license may be found at > > > > +# http://opensource.org/licenses/bsd-license.php > > > > +# > > > > +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, > > > > +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. > > > > +# > > > > +#**/ > > > > + > > > > +[Defines] > > > > + INF_VERSION = 0x00010005 > > > > + BASE_NAME = StandaloneMmNorFlash > > > > + FILE_GUID = 166F677B-DAC9-4AE4-AD34-2FF2504B0637 > > > > + MODULE_TYPE = MM_STANDALONE > > > > + VERSION_STRING = 1.0 > > > > + PI_SPECIFICATION_VERSION = 0x00010032 > > > > + ENTRY_POINT = NorFlashInitialise > > > > + > > > > +[Sources.common] > > > > + NorFlash.c > > > > + NorFlashFvb.c > > > > + NorFlashStandaloneMm.c > > > > + > > > > +[Packages] > > > > + ArmPkg/ArmPkg.dec > > > > + ArmPlatformPkg/ArmPlatformPkg.dec > > > > + MdePkg/MdePkg.dec > > > > + MdeModulePkg/MdeModulePkg.dec > > > > + StandaloneMmPkg/StandaloneMmPkg.dec > > > > + > > > > +[LibraryClasses] > > > > + ArmLib > > > > + ArmSvcLib > > > > + BaseMemoryLib > > > > + BaseLib > > > > + DebugLib > > > > + MemoryAllocationLib > > > > + MmServicesTableLib > > > > + NorFlashPlatformLib > > > > + StandaloneMmDriverEntryPoint > > > > + > > > > +[Guids] > > > > + gEfiSystemNvDataFvGuid > > > > + gEfiVariableGuid > > > > + gEfiAuthenticatedVariableGuid > > > > + > > > > +[Protocols] > > > > + gEfiSmmFirmwareVolumeBlockProtocolGuid > > > > + > > > > +[Pcd.common] > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase > > > > + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize > > > > + > > > > + gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked > > > > + > > > > +[Depex] > > > > + TRUE > > > > -- > > > > 2.7.4 > > > > > > > > _______________________________________________ > > > > edk2-devel mailing list > > > > edk2-devel@lists.01.org > > > > https://lists.01.org/mailman/listinfo/edk2-devel > > > > > > > > > ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 5:59 ` Jagadeesh Ujja @ 2019-04-29 6:52 ` Ard Biesheuvel 2019-04-29 7:58 ` Leif Lindholm 0 siblings, 1 reply; 10+ messages in thread From: Ard Biesheuvel @ 2019-04-29 6:52 UTC (permalink / raw) To: edk2-devel-groups-io, Jagadeesh Ujja; +Cc: Leif Lindholm On Mon, 29 Apr 2019 at 07:59, Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > hi Ard > > On Wed, Apr 24, 2019 at 6:37 PM Ard Biesheuvel > <ard.biesheuvel@linaro.org> wrote: > > > > On Wed, 24 Apr 2019 at 11:05, Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > > > > > Fwd to new EDKII development mailing list. > > > > > > hi Ard, > > > > > > Sorry about missing your previous comment and adding here. > > > > > > "Hello Jagadeesh, > > > > > > Why are you moving this driver into edk2-platforms? I'd prefer to have > > > > > > it alongside the non-MM version instead. > > > > > > That would allow us to share a lot more code between the two versions." > > > ----------------- > > > > > > my Point of view: > > > > > > In ArmPlatformPkg/Drivers/NorFlashDxe driver supports block I/O and > > > disk I/O protocols. > > > In case of StandaloneMM norflash driver the block I/O and disk I/O > > > protocols are not required > > > > > > We don’t want to remove support of block I/O and disk I/O protocols in > > > “ArmPlatformPkg/Drivers/NorFlashDxe” > > > In this case “NOR_FLASH_INSTANCE” is different in both > > > drivers(DXE/STANDALONEMM). So we end up with having 2 different > > > drivers. > > > > > > Even if we want to share common code then we end up with multiple > > > files as “NOR_FLASH_INSTANCE” is used in almost all files > > > Ex: “NorFlash.c” “NorFlash.h” NorFlashFvb.c > > > In this case “NorFlash.c” will have 2 copies one used by DXE and > > > other by STANDALONE_MM driver > > > > > > So instead of having 2 different drivers in one place > > > “ArmPlatformPkg/Drivers/NorFlashDxe” > > > added a new refactored nor flash driver in "Platform/ARM/Drivers" > > > > > > I am not sure if any other platform is using > > > “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and > > > disk I/O protocols > > > if we remove “support of block I/O and disk I/O protocols” then we > > > can share the common code easily. > > > > > > > I see your point. > > > > The only reason you need block i/o and disk i/o is to use ordinary > > partition and filesystem drivers. I guess Juno uses this for its magic > > filesystem? If not, I'd be glad to get rid of it. > > > > > Yes "block i/o and disk i/o of “ArmPlatformPkg/Drivers/NorFlashDxe” > driver is used even > in RD-platforms(edk2-platforms/Platform/ARM/SgiPkg/)(and JUNO) to list > partition. we don't want to break > legacy and want to have separate > "Platform/ARM/Drivers/StandaloneMmNorFlash/" driver. > In that case, could we move the existing code into edk2-platforms/Platform/ARM first? And then rip out the block i/o and disk i/o parts from the common driver? Leif, any thoughts? ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 6:52 ` Ard Biesheuvel @ 2019-04-29 7:58 ` Leif Lindholm 2019-04-29 8:17 ` Ard Biesheuvel 0 siblings, 1 reply; 10+ messages in thread From: Leif Lindholm @ 2019-04-29 7:58 UTC (permalink / raw) To: Ard Biesheuvel Cc: edk2-devel-groups-io, Jagadeesh Ujja, Thomas Panakamattam Abraham On Mon, Apr 29, 2019 at 08:52:46AM +0200, Ard Biesheuvel wrote: > > > > I am not sure if any other platform is using > > > > “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and > > > > disk I/O protocols > > > > if we remove “support of block I/O and disk I/O protocols” then we > > > > can share the common code easily. > > > > > > > > > > I see your point. > > > > > > The only reason you need block i/o and disk i/o is to use ordinary > > > partition and filesystem drivers. I guess Juno uses this for its magic > > > filesystem? If not, I'd be glad to get rid of it. > > > > > > > > Yes "block i/o and disk i/o of “ArmPlatformPkg/Drivers/NorFlashDxe” > > driver is used even > > in RD-platforms(edk2-platforms/Platform/ARM/SgiPkg/)(and JUNO) to list > > partition. we don't want to break > > legacy and want to have separate > > "Platform/ARM/Drivers/StandaloneMmNorFlash/" driver. > > In that case, could we move the existing code into > edk2-platforms/Platform/ARM first? And then rip out the block i/o and > disk i/o parts from the common driver? > > Leif, any thoughts? I guess my only thought is what to do about RDKQemu? Probably is doesn't make any use of the special sauce, but need to verify? Then we conside stripping it out of the ARM platforms medium-term. It's one of the last bastions of "let's be different". Even if it should be kept around, surely it could be revamped to sit on top of a sane, generic NorFlashDxe? I mean, the actually relevant bit is basically https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/mtd/afs.c, isn't it? +Thomas. / Leif ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 7:58 ` Leif Lindholm @ 2019-04-29 8:17 ` Ard Biesheuvel 2019-04-29 8:52 ` Leif Lindholm 0 siblings, 1 reply; 10+ messages in thread From: Ard Biesheuvel @ 2019-04-29 8:17 UTC (permalink / raw) To: Leif Lindholm Cc: edk2-devel-groups-io, Jagadeesh Ujja, Thomas Panakamattam Abraham On Mon, 29 Apr 2019 at 09:58, Leif Lindholm <leif.lindholm@linaro.org> wrote: > > On Mon, Apr 29, 2019 at 08:52:46AM +0200, Ard Biesheuvel wrote: > > > > > I am not sure if any other platform is using > > > > > “ArmPlatformPkg/Drivers/NorFlashDxe” and may require block I/O and > > > > > disk I/O protocols > > > > > if we remove “support of block I/O and disk I/O protocols” then we > > > > > can share the common code easily. > > > > > > > > > > > > > I see your point. > > > > > > > > The only reason you need block i/o and disk i/o is to use ordinary > > > > partition and filesystem drivers. I guess Juno uses this for its magic > > > > filesystem? If not, I'd be glad to get rid of it. > > > > > > > > > > > Yes "block i/o and disk i/o of “ArmPlatformPkg/Drivers/NorFlashDxe” > > > driver is used even > > > in RD-platforms(edk2-platforms/Platform/ARM/SgiPkg/)(and JUNO) to list > > > partition. we don't want to break > > > legacy and want to have separate > > > "Platform/ARM/Drivers/StandaloneMmNorFlash/" driver. > > > > In that case, could we move the existing code into > > edk2-platforms/Platform/ARM first? And then rip out the block i/o and > > disk i/o parts from the common driver? > > > > Leif, any thoughts? > > I guess my only thought is what to do about RDKQemu? Probably is > doesn't make any use of the special sauce, but need to verify? > > Then we conside stripping it out of the ARM platforms > medium-term. It's one of the last bastions of "let's be different". > Even if it should be kept around, surely it could be revamped to sit > on top of a sane, generic NorFlashDxe? > > I mean, the actually relevant bit is basically > https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/mtd/afs.c, > isn't it? > > +Thomas. > AIUI, these things are entirely separate. Exposing NOR flash via block I/O and disk I/O permits the standard partition driver and FAT filesystem driver to bind to it, so that you can have a standard FAT ESP on NOR flash. I don't this is related at all to the BootMonFs stuff ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 8:17 ` Ard Biesheuvel @ 2019-04-29 8:52 ` Leif Lindholm 2019-04-29 12:21 ` Jagadeesh Ujja 0 siblings, 1 reply; 10+ messages in thread From: Leif Lindholm @ 2019-04-29 8:52 UTC (permalink / raw) To: Ard Biesheuvel Cc: edk2-devel-groups-io, Jagadeesh Ujja, Thomas Panakamattam Abraham On Mon, Apr 29, 2019 at 10:17:17AM +0200, Ard Biesheuvel wrote: > > I mean, the actually relevant bit is basically > > https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/mtd/afs.c, > > isn't it? > > > > +Thomas. > > AIUI, these things are entirely separate. Exposing NOR flash via block > I/O and disk I/O permits the standard partition driver and FAT > filesystem driver to bind to it, so that you can have a standard FAT > ESP on NOR flash. I don't this is related at all to the BootMonFs > stuff If so, that's even sillier. If it has any business remaining supported, that should be a separate driver consuming NorFlashDxe. And if ARM feels their platforms need it, they can write that driver. So how about we don't move it and just nuke the BlockIo/DiskIo bits? / Leif ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 8:52 ` Leif Lindholm @ 2019-04-29 12:21 ` Jagadeesh Ujja 2019-05-02 8:48 ` Ard Biesheuvel 0 siblings, 1 reply; 10+ messages in thread From: Jagadeesh Ujja @ 2019-04-29 12:21 UTC (permalink / raw) To: devel, Leif Lindholm; +Cc: Ard Biesheuvel, Thomas Panakamattam Abraham hi Ard/Leif On Mon, Apr 29, 2019 at 2:22 PM Leif Lindholm <leif.lindholm@linaro.org> wrote: > > On Mon, Apr 29, 2019 at 10:17:17AM +0200, Ard Biesheuvel wrote: > > > I mean, the actually relevant bit is basically > > > https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/mtd/afs.c, > > > isn't it? > > > > > > +Thomas. > > > > AIUI, these things are entirely separate. Exposing NOR flash via block > > I/O and disk I/O permits the standard partition driver and FAT > > filesystem driver to bind to it, so that you can have a standard FAT > > ESP on NOR flash. I don't this is related at all to the BootMonFs > > stuff > > If so, that's even sillier. If it has any business remaining > supported, that should be a separate driver consuming NorFlashDxe. > > And if ARM feels their platforms need it, they can write that driver. > > So how about we don't move it and just nuke the BlockIo/DiskIo bits? > > / > Leif > I am little bit confused here, please confirm I have to copy “ArmPlatformPkg/Drivers/NorFlashDxe” to edk2-platforms/Platform/ARM/Drivers first and then rip out the block i/o and disk i/o parts to get StandaloneNorFlash driver? And retain “ArmPlatformPkg/Drivers/NorFlashDxe” as it is ? thanks Jagadeesh > > ^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver 2019-04-29 12:21 ` Jagadeesh Ujja @ 2019-05-02 8:48 ` Ard Biesheuvel 0 siblings, 0 replies; 10+ messages in thread From: Ard Biesheuvel @ 2019-05-02 8:48 UTC (permalink / raw) To: edk2-devel-groups-io, Jagadeesh Ujja Cc: Leif Lindholm, Thomas Panakamattam Abraham On Mon, 29 Apr 2019 at 14:21, Jagadeesh Ujja <jagadeesh.ujja@arm.com> wrote: > > hi Ard/Leif > > On Mon, Apr 29, 2019 at 2:22 PM Leif Lindholm <leif.lindholm@linaro.org> wrote: > > > > On Mon, Apr 29, 2019 at 10:17:17AM +0200, Ard Biesheuvel wrote: > > > > I mean, the actually relevant bit is basically > > > > https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/mtd/afs.c, > > > > isn't it? > > > > > > > > +Thomas. > > > > > > AIUI, these things are entirely separate. Exposing NOR flash via block > > > I/O and disk I/O permits the standard partition driver and FAT > > > filesystem driver to bind to it, so that you can have a standard FAT > > > ESP on NOR flash. I don't this is related at all to the BootMonFs > > > stuff > > > > If so, that's even sillier. If it has any business remaining > > supported, that should be a separate driver consuming NorFlashDxe. > > > > And if ARM feels their platforms need it, they can write that driver. > > > > So how about we don't move it and just nuke the BlockIo/DiskIo bits? > > > > / > > Leif > > > I am little bit confused here, please confirm > I have to copy “ArmPlatformPkg/Drivers/NorFlashDxe” to > edk2-platforms/Platform/ARM/Drivers first and then rip out the block > i/o > and disk i/o parts to get StandaloneNorFlash driver? And retain > “ArmPlatformPkg/Drivers/NorFlashDxe” as it is ? > No. The idea is to remove block i/o and disk i/o from the NOR flash driver altogether, unless anyone has a compelling use case for them. ^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2019-05-02 8:49 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-04-02 13:10 [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver Jagadeesh Ujja
[not found] ` <CADpYukZHE6NY-U=EycJBVGbQ-XcxXpeT9w6svzWMePjvQXFciQ@mail.gmail.com>
2019-04-24 9:05 ` [edk2] " jagadeesh.ujja
2019-04-24 13:06 ` [edk2-devel] " Ard Biesheuvel
2019-04-29 5:59 ` Jagadeesh Ujja
2019-04-29 6:52 ` Ard Biesheuvel
2019-04-29 7:58 ` Leif Lindholm
2019-04-29 8:17 ` Ard Biesheuvel
2019-04-29 8:52 ` Leif Lindholm
2019-04-29 12:21 ` Jagadeesh Ujja
2019-05-02 8:48 ` Ard Biesheuvel
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox