From: "Jagadeesh Ujja" <jagadeesh.ujja@arm.com>
To: devel@edk2.groups.io, Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Leif Lindholm <leif.lindholm@linaro.org>
Subject: Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver
Date: Mon, 29 Apr 2019 11:29:16 +0530 [thread overview]
Message-ID: <CADpYukYbf=eW6hHiez5uBMRrbRH5Zm+UD6y_eEsm8n-HMUx_CQ@mail.gmail.com> (raw)
In-Reply-To: <CAKv+Gu-K5SWY6XUSANWPBRsFGz=YEo0B-CDc_AbzQZEO-VuNkA@mail.gmail.com>
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
> >
> >
> >
>
>
>
next prev parent reply other threads:[~2019-04-29 5:59 UTC|newest]
Thread overview: 10+ messages / expand[flat|nested] mbox.gz Atom feed top
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 [this message]
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
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to='CADpYukYbf=eW6hHiez5uBMRrbRH5Zm+UD6y_eEsm8n-HMUx_CQ@mail.gmail.com' \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox