From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: mx.groups.io; dkim=missing; spf=pass (domain: arm.com, ip: 217.140.101.70, mailfrom: jagadeesh.ujja@arm.com) Received: from foss.arm.com (foss.arm.com [217.140.101.70]) by groups.io with SMTP; Sun, 28 Apr 2019 22:59:34 -0700 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0B97AEBD for ; Sun, 28 Apr 2019 22:59:34 -0700 (PDT) Received: from mail-it1-f178.google.com (usa-sjc-mx-foss1.foss.arm.com [217.140.101.70]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BF9283F740 for ; Sun, 28 Apr 2019 22:59:33 -0700 (PDT) Received: by mail-it1-f178.google.com with SMTP id v143so3929812itc.1 for ; Sun, 28 Apr 2019 22:59:33 -0700 (PDT) X-Gm-Message-State: APjAAAVK6BwX5dCAMmaf1likjFTIrekS/SM4Rr3QLv2EBi5/fjwPO12c 0eXI7M3ny1d76nZCD81i3fqxs0o6Zw/kNWhyybQ= X-Google-Smtp-Source: APXvYqynD5MJrlRizFico7DwfRnfAAqkFos8GljZ+/3R6HTCwHRI5I2klwvLLsAs2tiqc/1AAlSoz41n5SePXLkeESc= X-Received: by 2002:a24:d4:: with SMTP id 203mr15500130ita.133.1556517568401; Sun, 28 Apr 2019 22:59:28 -0700 (PDT) MIME-Version: 1.0 References: <1554210602-2957-1-git-send-email-jagadeesh.ujja@arm.com> In-Reply-To: From: "Jagadeesh Ujja" Date: Mon, 29 Apr 2019 11:29:16 +0530 X-Gmail-Original-Message-ID: Message-ID: Subject: Re: [edk2-devel] [edk2] [PATCH v2 edk2-platforms] Platform/ARM/Drivers: Add Nor Flash Driver To: devel@edk2.groups.io, Ard Biesheuvel Cc: Leif Lindholm Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable hi Ard On Wed, Apr 24, 2019 at 6:37 PM Ard Biesheuvel wrote: > > On Wed, 24 Apr 2019 at 11:05, Jagadeesh Ujja wr= ote: > > > > 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 hav= e > > > > 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=E2=80=99t want to remove support of block I/O and disk I/O prot= ocols in > > =E2=80=9CArmPlatformPkg/Drivers/NorFlashDxe=E2=80=9D > > In this case =E2=80=9CNOR_FLASH_INSTANCE=E2=80=9D 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 =E2=80=9CNOR_FLASH_INSTANCE=E2=80=9D is used in almost all f= iles > > Ex: =E2=80=9CNorFlash.c=E2=80=9D =E2=80=9CNorFlash.h=E2=80=9D NorFlas= hFvb.c > > In this case =E2=80=9CNorFlash.c=E2=80=9D will have 2 copies one used= by DXE and > > other by STANDALONE_MM driver > > > > So instead of having 2 different drivers in one place > > =E2=80=9CArmPlatformPkg/Drivers/NorFlashDxe=E2=80=9D > > added a new refactored nor flash driver in "Platform/ARM/Drivers" > > > > I am not sure if any other platform is using > > =E2=80=9CArmPlatformPkg/Drivers/NorFlashDxe=E2=80=9D and may require b= lock I/O and > > disk I/O protocols > > if we remove =E2=80=9Csupport of block I/O and disk I/O protocols=E2= =80=9D 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 =E2=80=9CArmPlatformPkg/Drivers/NorFlashD= xe=E2=80=9D 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 = 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 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 > > > > --- > > > > Changes since v1: > > > > - This is a next version of patch > > > > =E2=80=9C[edk2] [PATCH 0/2] Allow use of ArmPlatformPkg NOR flas= h driver in StandaloneMM=E2=80=9D > > > > 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 b= lock 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.in= f | 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-lice= nse.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" = BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRE= SS OR IMPLIED. > > > > + > > > > +**/ > > > > + > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > + > > > > +#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 =3D MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2)= ); > > > > + > > > > + // Decode block lock status > > > > + LockStatus =3D FOLD_32BIT_INTO_16BIT (LockStatus); > > > > + > > > > + if ((LockStatus & 0x2) !=3D 0) { > > > > + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block L= OCKED DOWN\n")); > > > > + } > > > > + > > > > + return ((LockStatus & 0x1) !=3D 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) =3D=3D 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 =3D MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress= , 2)); > > > > + > > > > + // Decode block lock status > > > > + LockStatus =3D FOLD_32BIT_INTO_16BIT (LockStatus); > > > > + } while ((LockStatus & 0x1) =3D=3D 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 =3D NorFlashReadStatusRegister (Instance, BlockA= ddress); > > > > + } while ((LockStatus & P30_SR_BIT_WRITE) !=3D P30_SR_BIT_WRIT= E); > > > > + } > > > > + > > > > + // Put device back into Read Array mode > > > > + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "UnlockSingleBlock: BlockAddress=3D0x%08x\n", BlockAddress)); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashUnlockSingleBlockIfNecessary ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + > > > > + Status =3D EFI_SUCCESS; > > > > + > > > > + if (NorFlashBlockIsLocked (Instance, BlockAddress) =3D=3D TRUE)= { > > > > + Status =3D NorFlashUnlockSingleBlock (Instance, BlockAddress)= ; > > > > + } > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + * The following function presumes that the block has already bee= n unlocked. > > > > + **/ > > > > +STATIC > > > > +EFI_STATUS > > > > +NorFlashEraseSingleBlock ( > > > > + IN NOR_FLASH_INSTANCE *Instance, > > > > + IN UINTN BlockAddress > > > > + ) > > > > +{ > > > > + EFI_STATUS Status; > > > > + UINT32 StatusRegister; > > > > + > > > > + Status =3D 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 =3D NorFlashReadStatusRegister (Instance, Bloc= kAddress); > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) !=3D P30_SR_BIT_WR= ITE); > > > > + > > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=3D0x%08x: VPP Range Error\n"= , BlockAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) = = =3D=3D > > > > + (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=3D0x%08x: Command Sequence E= rror\n", > > > > + BlockAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_ERASE) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=3D0x%08x: Block Erase Error = StatusRegister:0x%X\n", > > > > + BlockAddress, StatusRegister)); > > > > + Status =3D 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=3D0x%08x: Block Locked Error= \n", > > > > + BlockAddress)); > > > > + Status =3D EFI_WRITE_PROTECTED; > > > > + } > > > > + > > > > + if (EFI_ERROR (Status)) { > > > > + // Clear the Status Register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLE= AR_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 =3D 0; > > > > + // The block erase might fail a first time (SW bug ?). Retry it= ... > > > > + do { > > > > + // Unlock the block if we have to > > > > + Status =3D NorFlashUnlockSingleBlockIfNecessary (Instance, Bl= ockAddress); > > > > + if (EFI_ERROR (Status)) { > > > > + break; > > > > + } > > > > + Status =3D NorFlashEraseSingleBlock (Instance, BlockAddress); > > > > + Index++; > > > > + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status =3D=3D EFI_= WRITE_PROTECTED)); > > > > + > > > > + if (Index =3D=3D NOR_FLASH_ERASE_RETRY) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "EraseSingleBlock(BlockAddress=3D0x%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 =3D 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 =3D NorFlashReadStatusRegister (Instance, Word= Address); > > > > + // The chip is busy while the WRITE bit is not asserted > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) !=3D P30_SR_BIT_WR= ITE); > > > > + > > > > + > > > > + // 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 =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n= ", > > > > + WordAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect = Error\n", > > > > + WordAddress)); > > > > + Status =3D 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 me= thod. > > > > + * > > > > + * 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 fun= ction 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 begi= nning of a > > > > + * 32-bit word boundary,then programming time is doubled and powe= r consumption > > > > + * is increased. Therefore, it is a requirement to align buffer w= rites 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 =3D MAX_BUFFERED_PROG_ITERATIONS; > > > > + BufferAvailable =3D FALSE; > > > > + > > > > + // Check that the target address does not cross a 32-word bound= ary. > > > > + if ((TargetAddress & BOUNDARY_OF_32_WORDS) !=3D 0) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Check there are some data to program > > > > + if (BufferSizeInBytes =3D=3D 0) { > > > > + return EFI_BUFFER_TOO_SMALL; > > > > + } > > > > + > > > > + // Check that the buffer size does not exceed the maximum hardw= are 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) !=3D 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Pre-programming conditions checked, now start the algorithm. > > > > + > > > > + // Prepare the data destination address > > > > + Data =3D (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) =3D=3D P30_SR_BIT_WRITE) { > > > > + BufferAvailable =3D TRUE; > > > > + } > > > > + > > > > + // Update the loop counter > > > > + WaitForBuffer--; > > > > + > > > > + } while ((WaitForBuffer > 0) && (BufferAvailable =3D=3D FALSE))= ; > > > > + > > > > + // The buffer was not available for writing > > > > + if (WaitForBuffer =3D=3D 0) { > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + goto EXIT; > > > > + } > > > > + > > > > + // From now on we work in 32-bit words > > > > + BufferSizeInWords =3D 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=3D0; Count < BufferSizeInWords; Count++, Data++, Buf= fer++) { > > > > + MmioWrite32 ((UINTN)Data, *Buffer); > > > > + } > > > > + > > > > + // Issue the Buffered Program Confirm command, to start the pro= gramming operation > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFE= RED_PROGRAM_CONFIRM); > > > > + > > > > + // Wait for the write to complete and then check for any errors= ; > > > > + // i.e. check the Status Register > > > > + do { > > > > + StatusRegister =3D NorFlashReadStatusRegister (Instance, Targ= etAddress); > > > > + // The chip is busy while the WRITE bit is not asserted > > > > + } while ((StatusRegister & P30_SR_BIT_WRITE) !=3D P30_SR_BIT_WR= ITE); > > > > + > > > > + > > > > + // Perform a full status check: > > > > + // Mask the relevant bits of Status Register. > > > > + // Everything should be zero, if not, we have a problem > > > > + > > > > + Status =3D EFI_SUCCESS; > > > > + > > > > + if (StatusRegister & P30_SR_BIT_VPP) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X)= : VPP Range Error\n", > > > > + TargetAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_PROGRAM) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X)= : Program Error\n", > > > > + TargetAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashWriteBuffer (TargetAddress:0x%X)= : Device Protect Error\n", > > > > + TargetAddress)); > > > > + Status =3D EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + if (!EFI_ERROR (Status)) { > > > > + // Clear the Status Register > > > > + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLE= AR_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 =3D EFI_SUCCESS; > > > > + > > > > + // Get the physical address of the block > > > > + BlockAddress =3D GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAdd= ress, Lba, BlockSizeInWords * 4); > > > > + > > > > + // Start writing from the first address at the start of the blo= ck > > > > + WordAddress =3D BlockAddress; > > > > + > > > > + NorFlashLock (&Lock); > > > > + > > > > + Status =3D NorFlashUnlockAndEraseSingleBlock (Instance, BlockAd= dress); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "WriteSingleBlock: ERROR - Failed to Unlock and Erase the s= ingle block at 0x%X\n", > > > > + BlockAddress)); > > > > + goto EXIT; > > > > + } > > > > + > > > > + // To speed up the programming operation, NOR Flash is programm= ed 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) =3D=3D 0x00) { > > > > + > > > > + // First, break the entire block into buffer-sized chunks. > > > > + BuffersInBlock =3D (UINTN)(BlockSizeInWords * 4) / P30_MAX_BU= FFER_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=3D0; > > > > + BufferIndex < BuffersInBlock; > > > > + BufferIndex++, WordAddress +=3D P30_MAX_BUFFER_SIZE_IN_B= YTES, > > > > + DataBuffer +=3D P30_MAX_BUFFER_SIZE_IN_WORDS > > > > + ) { > > > > + // Check the buffer to see if it contains any data (not set= all 1s). > > > > + for (Cnt =3D 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) = { > > > > + if (~DataBuffer[Cnt] !=3D 0 ) { > > > > + // Some data found, write the buffer. > > > > + Status =3D 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 =3D BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_= WORDS; > > > > + > > > > + if (RemainingWords !=3D 0) { > > > > + Status =3D NorFlashWriteBuffer (Instance, WordAddress, (Rem= ainingWords * 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=3D0; > > > > + WordIndex > > > + WordIndex++, DataBuffer++, WordAddress =3D WordAddress + = 4) { > > > > + Status =3D 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 =3D \"%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 =3D EFI_SUCCESS; > > > > + EFI_LBA CurrentBlock; > > > > + UINT32 BlockSizeInWords; > > > > + UINT32 NumBlocks; > > > > + UINT32 BlockCount; > > > > + > > > > + // The buffer must be valid > > > > + if (Buffer =3D=3D NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // We must have some bytes to read > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: BufferSizeInBytes=3D0x%x\n", BufferSize= InBytes)); > > > > + if (BufferSizeInBytes =3D=3D 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 =3D0x%x\n", Instance= ->BlockSize)); > > > > + if ((BufferSizeInBytes % Instance->BlockSize) !=3D 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // All blocks must be within the device > > > > + NumBlocks =3D ((UINT32)BufferSizeInBytes) / Instance->BlockSize= ; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: NumBlocks=3D%d, LastBlock=3D%ld, Lba=3D= %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 =3D 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 *ReadBuffe= r > > > > + pWriteBuffer =3D (UINT32 *)Buffer; > > > > + > > > > + CurrentBlock =3D Lba; > > > > + for (BlockCount=3D0; > > > > + BlockCount < NumBlocks; > > > > + BlockCount++, CurrentBlock++, pWriteBuffer =3D pWriteBuffe= r + BlockSizeInWords) { > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentB= lock)); > > > > + > > > > + Status =3D NorFlashWriteFullBlock (Instance, CurrentBlock, pW= riteBuffer, BlockSizeInWords); > > > > + > > > > + if (EFI_ERROR (Status)) { > > > > + break; > > > > + } > > > > + } > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status =3D \"%r= \".\n", Status)); > > > > + return Status; > > > > +} > > > > + > > > > +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & (= (align) - 1)) =3D=3D 0) > > > > + > > > > +/** > > > > + Copy Length bytes from Source to Destination, using aligned acc= esses only. > > > > + Note that this implementation uses memcpy() semantics rather th= en 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= >=3D 8) { > > > > + Destination64 =3D DestinationBuffer; > > > > + Source64 =3D SourceBuffer; > > > > + while (Length >=3D 8) { > > > > + *Destination64++ =3D *Source64++; > > > > + Length -=3D 8; > > > > + } > > > > + > > > > + Destination8 =3D (UINT8 *)Destination64; > > > > + Source8 =3D (CONST UINT8 *)Source64; > > > > + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) &&= Length >=3D 4) { > > > > + Destination32 =3D DestinationBuffer; > > > > + Source32 =3D SourceBuffer; > > > > + while (Length >=3D 4) { > > > > + *Destination32++ =3D *Source32++; > > > > + Length -=3D 4; > > > > + } > > > > + > > > > + Destination8 =3D (UINT8 *)Destination32; > > > > + Source8 =3D (CONST UINT8 *)Source32; > > > > + } else { > > > > + Destination8 =3D DestinationBuffer; > > > > + Source8 =3D SourceBuffer; > > > > + } > > > > + while (Length-- !=3D 0) { > > > > + *Destination8++ =3D *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=3D0x%xB BlockSize=3D0x%xB Las= tBlock=3D%ld, Lba=3D%ld.\n", > > > > + BufferSizeInBytes, Instance->BlockSize, Instance->LastBlock, = Lba)); > > > > + > > > > + // The buffer must be valid > > > > + if (Buffer =3D=3D NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Return if we have not any byte to read > > > > + if (BufferSizeInBytes =3D=3D 0) { > > > > + return EFI_SUCCESS; > > > > + } > > > > + > > > > + // The size of the buffer must be a multiple of the block size > > > > + if ((BufferSizeInBytes % Instance->BlockSize) !=3D 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // All blocks must be within the device > > > > + NumBlocks =3D ((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 =3D GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAdd= ress, > > > > + 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 =3D=3D NULL) { > > > > + return EFI_INVALID_PARAMETER; > > > > + } > > > > + > > > > + // Return if we have not any byte to read > > > > + if (BufferSizeInBytes =3D=3D 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 =3D GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAdd= ress, > > > > + 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), Buffer= SizeInBytes); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/* > > > > + Write a full or portion of a block. It must not span block boun= daries; > > > > + that is, Offset + *NumBytes <=3D 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 =3D 0; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "NorFlashWriteSingleBlock(Parameters: Lba=3D%ld, Offset=3D0x%= x, *NumBytes=3D0x%x, Buffer @ 0x%08x)\n", > > > > + Lba, Offset, *NumBytes, Buffer)); > > > > + > > > > + // Cache the block size to avoid de-referencing pointers all th= e time > > > > + BlockSize =3D Instance->BlockSize; > > > > + > > > > + // The write must not span block boundaries. > > > > + // We need to check each variable individually because adding t= wo > > > > + // large values together overflows. > > > > + if ( ( Offset >=3D BlockSize ) || > > > > + ( *NumBytes > BlockSize ) || > > > > + ( (Offset + *NumBytes) > BlockSize ) ) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > > + (Offset=3D0x%x + NumBytes=3D0x%x) > BlockSize=3D0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // We must have some bytes to write > > > > + if (*NumBytes =3D=3D 0) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: \ > > > > + (Offset=3D0x%x + NumBytes=3D0x%x) > BlockSize=3D0x%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 <=3D 128) { > > > > + // Check to see if we need to erase before programming the da= ta 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 rewri= te all of it. > > > > + DoErase =3D FALSE; > > > > + BytesToWrite =3D *NumBytes; > > > > + CurOffset =3D Offset; > > > > + > > > > + while (BytesToWrite > 0) { > > > > + // Read full word from NOR, splice as required. A word is t= he smallest > > > > + // unit we can write. > > > > + TempStatus =3D NorFlashRead (Instance, Lba, CurOffset & ~(0= x3), sizeof (Tmp), &Tmp); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + // Physical address of word in NOR to write. > > > > + WordAddr =3D (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (= Instance->RegionBaseAddress, > > > > + Lb= a, BlockSize); > > > > + // The word of data that is to be written. > > > > + TmpBuf =3D *((UINT32*)(Buffer + (*NumBytes - BytesToWrite))= ); > > > > + > > > > + // First do word aligned chunks. > > > > + if ((CurOffset & 0x3) =3D=3D 0) { > > > > + if (BytesToWrite >=3D 4) { > > > > + // Is the destination still in 'erased' state? > > > > + if (~Tmp !=3D 0) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase =3D TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Write this word to NOR > > > > + WordToWrite =3D TmpBuf; > > > > + CurOffset +=3D sizeof (TmpBuf); > > > > + BytesToWrite -=3D sizeof (TmpBuf); > > > > + } else { > > > > + // BytesToWrite < 4. Do small writes and left-overs > > > > + Mask =3D ~((~0) << (BytesToWrite * 8)); > > > > + // Mask out the bytes we want. > > > > + TmpBuf &=3D Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) !=3D Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase =3D TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite =3D (Tmp & ~Mask) | TmpBuf; > > > > + CurOffset +=3D BytesToWrite; > > > > + BytesToWrite =3D 0; > > > > + } > > > > + } else { > > > > + // Do multiple words, but starting unaligned. > > > > + if (BytesToWrite > (4 - (CurOffset & 0x3))) { > > > > + Mask =3D ((~0) << ((CurOffset & 0x3) * 8)); > > > > + // Mask out the bytes we want. > > > > + TmpBuf &=3D Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) !=3D Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase =3D TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite =3D (Tmp & ~Mask) | TmpBuf; > > > > + BytesToWrite -=3D (4 - (CurOffset & 0x3)); > > > > + CurOffset +=3D (4 - (CurOffset & 0x3)); > > > > + } else { > > > > + // Unaligned and fits in one word. > > > > + Mask =3D (~((~0) << (BytesToWrite * 8))) << ((CurOffset= & 0x3) * 8); > > > > + // Mask out the bytes we want. > > > > + TmpBuf =3D (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask; > > > > + // Is the destination still in 'erased' state? > > > > + if ((Tmp & Mask) !=3D Mask) { > > > > + // Check to see if we are only changing bits to zero. > > > > + if ((Tmp ^ TmpBuf) & TmpBuf) { > > > > + DoErase =3D TRUE; > > > > + break; > > > > + } > > > > + } > > > > + // Merge old and new data. Write merged word to NOR > > > > + WordToWrite =3D (Tmp & ~Mask) | TmpBuf; > > > > + CurOffset +=3D BytesToWrite; > > > > + BytesToWrite =3D 0; > > > > + } > > > > + } > > > > + > > > > + // > > > > + // Write the word to NOR. > > > > + // > > > > + > > > > + BlockAddress =3D GET_NOR_BLOCK_ADDRESS (Instance->RegionBas= eAddress, Lba, BlockSize); > > > > + if (BlockAddress !=3D PrevBlockAddress) { > > > > + TempStatus =3D NorFlashUnlockSingleBlockIfNecessary (Inst= ance, BlockAddress); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + PrevBlockAddress =3D BlockAddress; > > > > + } > > > > + TempStatus =3D NorFlashWriteSingleWord (Instance, WordAddr,= WordToWrite); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + } > > > > + // Exit if we got here and could write all the data. Otherwis= e do the > > > > + // Erase-Write cycle. > > > > + if (!DoErase) { > > > > + return EFI_SUCCESS; > > > > + } > > > > + } > > > > + > > > > + // Check we did get some memory. Buffer is BlockSize. > > > > + if (Instance->ShadowBuffer =3D=3D NULL) { > > > > + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"))= ; > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + > > > > + // Read NOR Flash data into shadow buffer > > > > + TempStatus =3D NorFlashReadBlocks (Instance, Lba, BlockSize, In= stance->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 a= rea > > > > + CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffe= r, *NumBytes); > > > > + > > > > + // Write the modified buffer back to the NorFlash > > > > + TempStatus =3D NorFlashWriteBlocks (Instance, Lba, BlockSize, I= nstance->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 de= vices > > > > + // 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.ph= p > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" = BASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRE= SS OR IMPLIED. > > > > + > > > > +**/ > > > > + > > > > +#ifndef __NOR_FLASH_H__ > > > > +#define __NOR_FLASH_H__ > > > > + > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > + > > > > +#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 =3D 128 b= ytes > > > > +#define P30_MAX_BUFFER_SIZE_IN_BYTES ( ( UINTN ) 128 ) > > > > +#define P30_MAX_BUFFER_SIZE_IN_WORDS ( P30_MAX_BUFFER_SIZE_IN_B= YTES/ ( ( 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_FLAS= H_INSTANCE, \ > > > > + FvbProtocol,= \ > > > > + NOR_FLASH_SI= GNATURE) > > > > +#define INSTANCE_FROM_BLKIO_THIS(a) CR (a, NOR_FLAS= H_INSTANCE, \ > > > > + BlockIoProto= col, \ > > > > + NOR_FLASH_SI= GNATURE) > > > > +#define INSTANCE_FROM_DISKIO_THIS(a) CR (a, NOR_FLAS= H_INSTANCE, \ > > > > + DiskIoProtoc= ol, \ > > > > + NOR_FLASH_SI= GNATURE) > > > > + > > > > +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTA= NCE; > > > > +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 *NumberOfBloc= ks > > > > + ); > > > > + > > > > +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 o= f the > > > > + BSD License which accompanies this distribution. The full text o= f the > > > > + license may be found at http://opensource.org/licenses/bsd-licen= se.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" B= ASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRES= S OR IMPLIED. > > > > + > > > > + --*/ > > > > + > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > + > > > > +#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 =3D sizeof (EFI_FIRMWARE_VOLUME_HEADER) + > > > > + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + > > > > + sizeof (VARIABLE_STORE_HEADER); > > > > + Headers =3D AllocateZeroPool (HeadersLength); > > > > + > > > > + // FirmwareVolumeHeader->FvLength is declared to have the Varia= ble area AND > > > > + // the FTW working area AND the FTW Spare contiguous. > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) =3D=3D > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingBase)); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) =3D=3D > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareBase)); > > > > + > > > > + // Check if the size of the area is at least one block size > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageVariableSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageVariableSize) / Instance->Bl= ockSize > 0)); > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwWorkingSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) / Instance->= BlockSize > 0)); > > > > + ASSERT ((PcdGet32 (PcdFlashNvStorageFtwSpareSize) > 0) && > > > > + (PcdGet32 (PcdFlashNvStorageFtwSpareSize) / Instance->Bl= ockSize > 0)); > > > > + > > > > + // Ensure the Variable area Base Addresses are aligned on a > > > > + // block size boundaries > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageVariableBase) % Instance->Bl= ockSize =3D=3D 0); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwWorkingBase) % Instance->= BlockSize =3D=3D 0); > > > > + ASSERT (PcdGet32 (PcdFlashNvStorageFtwSpareBase) % Instance->Bl= ockSize =3D=3D 0); > > > > + > > > > + // > > > > + // EFI_FIRMWARE_VOLUME_HEADER > > > > + // > > > > + FirmwareVolumeHeader =3D (EFI_FIRMWARE_VOLUME_HEADER*)Headers; > > > > + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvD= ataFvGuid); > > > > + FirmwareVolumeHeader->FvLength =3D > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize); > > > > + FirmwareVolumeHeader->Signature =3D EFI_FVH_SIGNATURE; > > > > + FirmwareVolumeHeader->Attributes =3D (EFI_FVB_ATTRIBUTES_2) ( > > > > + EFI_FVB2_READ_ENABLED_C= AP | > > > > + // Reads may be enabled > > > > + EFI_FVB2_READ_STATUS = | > > > > + // Reads are currently = enabled > > > > + EFI_FVB2_STICKY_WRITE = | > > > > + // A block erase is req= uired to flip > > > > + // bits into EFI_FVB2_E= RASE_POLARITY > > > > + EFI_FVB2_MEMORY_MAPPED = | > > > > + // It is memory mapped > > > > + EFI_FVB2_ERASE_POLARITY= | > > > > + // After erasure all bi= ts take this > > > > + // value (i.e. '1') > > > > + EFI_FVB2_WRITE_STATUS = | > > > > + // Writes are currently= enabled > > > > + EFI_FVB2_WRITE_ENABLED_= CAP > > > > + // Writes may be enable= d > > > > + ); > > > > + FirmwareVolumeHeader->HeaderLength =3D sizeof (EFI_FIRMWARE_VOL= UME_HEADER) + > > > > + sizeof (EFI_FV_BLOCK_MAP_E= NTRY); > > > > + FirmwareVolumeHeader->Revision =3D EFI_FVH_REVISION; > > > > + FirmwareVolumeHeader->BlockMap[0].NumBlocks =3D Instance->LastB= lock + 1; > > > > + FirmwareVolumeHeader->BlockMap[0].Length =3D Instance->Blo= ckSize; > > > > + FirmwareVolumeHeader->BlockMap[1].NumBlocks =3D 0; > > > > + FirmwareVolumeHeader->BlockMap[1].Length =3D 0; > > > > + FirmwareVolumeHeader->Checksum =3D CalculateCheckSum16 ( > > > > + (UINT16*)FirmwareVolumeHeade= r, > > > > + FirmwareVolumeHeader->Heade= rLength); > > > > + > > > > + // > > > > + // VARIABLE_STORE_HEADER > > > > + // > > > > + VariableStoreHeader =3D (VARIABLE_STORE_HEADER*)((UINTN)Headers= + > > > > + FirmwareVolumeHeader->HeaderLength); > > > > + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVa= riableGuid); > > > > + VariableStoreHeader->Size =3D PcdGet32 (PcdFlashNvStorageVariab= leSize) - > > > > + FirmwareVolumeHeader->Head= erLength; > > > > + VariableStoreHeader->Format =3D VARIABLE_STORE_FORMA= TTED; > > > > + VariableStoreHeader->State =3D VARIABLE_STORE_HEALT= HY; > > > > + > > > > + // Install the combined super-header in the NorFlash > > > > + Status =3D FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLeng= th, 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 =3D (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBa= seAddress; > > > > + > > > > + FvLength =3D 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 !=3D EFI_FVH_REVISION) > > > > + || (FwVolHeader->Signature !=3D EFI_FVH_SIGNATURE) > > > > + || (FwVolHeader->FvLength !=3D 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) =3D=3D FALSE ) { > > > > + DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\= n", > > > > + __FUNCTION__)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + // Verify the header checksum > > > > + Checksum =3D CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader-= >HeaderLength); > > > > + if (Checksum !=3D 0) { > > > > + DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%= X)\n", > > > > + __FUNCTION__, Checksum)); > > > > + return EFI_NOT_FOUND; > > > > + } > > > > + > > > > + VariableStoreHeader =3D (VARIABLE_STORE_HEADER*)((UINTN)FwVolHe= ader + > > > > + 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 =3D PcdGet32 (PcdFlashNvStorageVariableSize= ) - > > > > + FwVolHeader->HeaderLength; > > > > + if (VariableStoreHeader->Size !=3D 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_PRO= TOCOL 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 =3D INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + FlashFvbAttributes =3D (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_ERA= SE_POLARITY > > > > + EFI_FVB2_MEMORY_MAPPED | > > > > + // It is memory mapped > > > > + EFI_FVB2_ERASE_POLARITY > > > > + // After erasure all bits take this value (i.e. '1') > > > > + > > > > + ); > > > > + > > > > + *Attributes =3D FlashFvbAttributes; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes)); > > > > + > > > > + return EFI_SUCCESS; > > > > +} > > > > + > > > > +/** > > > > + The SetAttributes() function sets configurable firmware volume a= ttributes > > > > + and returns the new settings of the firmware volume. > > > > + > > > > + > > > > + @param This Indicates the > > > > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTO= COL instance. > > > > + > > > > + @param Attributes On input, Attributes is a pointe= r to > > > > + EFI_FVB_ATTRIBUTES_2 that contai= ns the desired > > > > + firmware volume settings. On suc= cessful 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 w= ere returned. > > > > + > > > > + @retval EFI_INVALID_PARAMETER The attributes requested are in = conflict with > > > > + the capabilities > > > > + as declared in the firmware volu= me 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_BLOC= K2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Address Pointer to a caller-allocated > > > > + EFI_PHYSICAL_ADDRESS that, on successf= ul > > > > + return from GetPhysicalAddress(), cont= ains the > > > > + base address of the firmware volume. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume base address was r= eturned. > > > > + > > > > + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapp= ed. > > > > + > > > > + **/ > > > > +EFI_STATUS > > > > +EFIAPI > > > > +FvbGetPhysicalAddress ( > > > > + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This, > > > > + OUT EFI_PHYSICAL_ADDRESS *Address > > > > + ) > > > > +{ > > > > + NOR_FLASH_INSTANCE *Instance; > > > > + > > > > + Instance =3D INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=3D0x%08= x)\n", > > > > + Instance->RegionBaseAddress)); > > > > + > > > > + ASSERT (Address !=3D NULL); > > > > + > > > > + *Address =3D 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_PROTO= COL instance. > > > > + > > > > + @param Lba Indicates the block for which to= return > > > > + the size. > > > > + > > > > + @param BlockSize Pointer to a caller-allocated UI= NTN in which > > > > + the size of the block is returne= d. > > > > + > > > > + @param NumberOfBlocks Pointer to a caller-allocated UI= NTN 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 rang= e. > > > > + > > > > + **/ > > > > +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 =3D INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=3D%ld, BlockSize=3D0x= %x, LastBlock=3D%ld)\n", > > > > + Lba, Instance->BlockSize, Instance->LastBlock)); > > > > + > > > > + if (Lba > Instance->LastBlock) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the l= ast Lba (%ld).\n", > > > > + Lba, Instance->LastBlock)); > > > > + Status =3D EFI_INVALID_PARAMETER; > > > > + } else { > > > > + // This is easy because in this platform each NorFlash device > > > > + // has equal sized blocks. > > > > + *BlockSize =3D (UINTN) Instance->BlockSize; > > > > + *NumberOfBlocks =3D (UINTN) (Instance->LastBlock - Lba + 1); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbGetBlockSize: *BlockSize=3D0x%x,*NumberOfBlocks=3D0x%x.= \n", > > > > + *BlockSize, *NumberOfBlocks)); > > > > + > > > > + Status =3D EFI_SUCCESS; > > > > + } > > > > + > > > > + return Status; > > > > +} > > > > + > > > > +/** > > > > + Reads the specified number of bytes into a buffer from the speci= fied 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_BL= OCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Lba The starting logical block index fro= m which to read. > > > > + > > > > + @param Offset Offset into the block at which to be= gin reading. > > > > + > > > > + @param NumBytes Pointer to a UINTN. > > > > + At entry, *NumBytes contains the tot= al size of the buffer. > > > > + At exit, *NumBytes contains the tota= l 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 success= fully,and contents are > > > > + in Buffer. > > > > + > > > > + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundar= y. > > > > + On output, NumBytes contains the tot= al number of bytes > > > > + returned in Buffer. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDi= sabled 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 =3D INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbRead(Parameters: Lba=3D%ld, Offset=3D0x%x, *NumBytes=3D0x= %x, Buffer @ 0x%08x)\n", > > > > + Instance->StartLba + Lba, Offset, *NumBytes, Buffer)); > > > > + > > > > + TempStatus =3D EFI_SUCCESS; > > > > + > > > > + // Cache the block size to avoid de-referencing pointers all th= e time > > > > + BlockSize =3D Instance->BlockSize; > > > > + > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbRead: Check if (Offset=3D0x%x + NumBytes=3D0x%x) <=3D Blo= ckSize=3D0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + > > > > + // The read must not span block boundaries. > > > > + // We need to check each variable individually because adding t= wo > > > > + // large values together overflows. > > > > + if ((Offset >=3D BlockSize) || > > > > + (*NumBytes > BlockSize) || > > > > + ((Offset + *NumBytes) > BlockSize)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=3D0x%x + Num= Bytes=3D0x%x) > BlockSize=3D0x%x\n", > > > > + Offset, *NumBytes, BlockSize )); > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // We must have some bytes to read > > > > + if (*NumBytes =3D=3D 0) { > > > > + return EFI_BAD_BUFFER_SIZE; > > > > + } > > > > + > > > > + // Decide if we are doing full block reads or not. > > > > + if (*NumBytes % BlockSize !=3D 0) { > > > > + TempStatus =3D NorFlashRead (Instance, Instance->StartLba + L= ba, Offset, *NumBytes, Buffer); > > > > + if (EFI_ERROR (TempStatus)) { > > > > + return EFI_DEVICE_ERROR; > > > > + } > > > > + } else { > > > > + // Read NOR Flash data into shadow buffer > > > > + TempStatus =3D NorFlashReadBlocks (Instance, Instance->StartL= ba + 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 th= e 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 cal= l > > > > + 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_BL= OCK2_PROTOCOL > > > > + instance. > > > > + > > > > + @param Lba The starting logical block index to = write to. > > > > + > > > > + @param Offset Offset into the block at which to be= gin writing. > > > > + > > > > + @param NumBytes The pointer to a UINTN. > > > > + At entry, *NumBytes contains the tot= al size of the > > > > + buffer. > > > > + At exit, *NumBytes contains the tota= l number of > > > > + bytes actually written. > > > > + > > > > + @param Buffer The pointer to a caller-allocated bu= ffer that contains > > > > + the source for the write. > > > > + > > > > + @retval EFI_SUCCESS The firmware volume was written succ= essfully. > > > > + > > > > + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LB= A boundary. > > > > + On output, NumBytes contains the tot= al number of bytes > > > > + actually written. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteD= isabled state. > > > > + > > > > + @retval EFI_DEVICE_ERROR The block device is malfunctioning a= nd 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 =3D 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_VOLUM= E_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 num= ber of blocks > > > > + to erase. > > > > + > > > > + The list is terminated with an > > > > + EFI_LBA_LIST_TERMINATOR. > > > > + For example, the following indic= ates 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 c= ompleted. > > > > + > > > > + @retval EFI_ACCESS_DENIED The firmware volume is in the Wr= iteDisabled state. > > > > + > > > > + @retval EFI_DEVICE_ERROR The block device is not function= ing correctly > > > > + and could not be written. > > > > + The firmware device may have bee= n partially erased. > > > > + > > > > + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed i= n the variable > > > > + argument list do not exist in th= e 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 =3D INSTANCE_FROM_FVB_THIS (This); > > > > + > > > > + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n")); > > > > + > > > > + Status =3D 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 =3D VA_ARG (Args, EFI_LBA); > > > > + > > > > + // Have we reached the end of the list? > > > > + if (StartingLba =3D=3D EFI_LBA_LIST_TERMINATOR) { > > > > + //Exit the while loop > > > > + break; > > > > + } > > > > + > > > > + // How many Lba blocks are we requested to erase? > > > > + NumOfLba =3D VA_ARG (Args, UINTN); > > > > + > > > > + // All blocks must be within range > > > > + DEBUG (( > > > > + DEBUG_BLKIO, > > > > + "FvbEraseBlocks: Check if: ( StartingLba=3D%ld + NumOfLba= =3D%Lu - 1 ) > LastBlock=3D%ld.\n", > > > > + Instance->StartLba + StartingLba, > > > > + (UINT64)NumOfLba, > > > > + Instance->LastBlock > > > > + )); > > > > + if ((NumOfLba =3D=3D 0) || > > > > + ((Instance->StartLba + StartingLba + NumOfLba - 1) > Insta= nce->LastBlock)) { > > > > + VA_END (Args); > > > > + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goe= s past the last Lba.\n")); > > > > + Status =3D 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 =3D VA_ARG (Args, EFI_LBA); > > > > + > > > > + // Have we reached the end of the list? > > > > + if (StartingLba =3D=3D EFI_LBA_LIST_TERMINATOR) { > > > > + // Exit the while loop > > > > + break; > > > > + } > > > > + > > > > + // How many Lba blocks are we requested to erase? > > > > + NumOfLba =3D VA_ARG (Args, UINTN); > > > > + > > > > + // Go through each one and erase it > > > > + while (NumOfLba > 0) { > > > > + > > > > + // Get the physical address of Lba to erase > > > > + BlockAddress =3D GET_NOR_BLOCK_ADDRESS ( > > > > + Instance->RegionBaseAddress, > > > > + Instance->StartLba + StartingLba, > > > > + Instance->BlockSize > > > > + ); > > > > + > > > > + // Erase it > > > > + DEBUG ((DEBUG_BLKIO, > > > > + "FvbEraseBlocks: Erasing Lba=3D%ld @ 0x%08x.\n", > > > > + Instance->StartLba + StartingLba, BlockAddress)); > > > > + Status =3D NorFlashUnlockAndEraseSingleBlock (Instance, Blo= ckAddress); > > > > + if (EFI_ERROR (Status)) { > > > > + VA_END (Args); > > > > + Status =3D 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/NorFlashSta= ndaloneMm.c b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandaloneM= m.c > > > > new file mode 100644 > > > > index 0000000..08e20ae > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandalone= Mm.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 o= f the BSD > > > > + License which accompanies this distribution. The full text of t= he license > > > > + may be found at http://opensource.org/licenses/bsd-license.php > > > > + > > > > + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" B= ASIS, > > > > + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRES= S OR IMPLIED. > > > > + > > > > + --*/ > > > > + > > > > +#include > > > > + > > > > +#include > > > > +#include > > > > +#include > > > > +#include > > > > + > > > > +#include "NorFlash.h" > > > > + > > > > +// > > > > +// Global variable declarations > > > > +// > > > > +STATIC NOR_FLASH_INSTANCE **mNorFlashInstances; > > > > +STATIC UINT32 mNorFlashDeviceCount; > > > > + > > > > +STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate =3D { > > > > + 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 !=3D NULL)); > > > > + > > > > + mFlashNvStorageVariableBase =3D FixedPcdGet32 (PcdFlashNvStorag= eVariableBase); > > > > + > > > > + // Set the index of the first LBA for the FVB > > > > + Instance->StartLba =3D (PcdGet32 (PcdFlashNvStorageVariableBase= ) - > > > > + Instance->RegionBaseAddress) / Instance->= BlockSize; > > > > + > > > > + // Determine if there is a valid header at the beginning of the= NorFlash > > > > + Status =3D 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", __F= UNCTION__)); > > > > + DEBUG ((DEBUG_INFO, "%a: Installing a correct one for this vo= lume.\n", > > > > + __FUNCTION__)); > > > > + > > > > + // Erase all the NorFlash that is reserved for variable stora= ge > > > > + FvbNumLba =3D (PcdGet32 (PcdFlashNvStorageVariableSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + > > > > + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / > > > > + Instance->BlockSize; > > > > + > > > > + Status =3D FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0= , FvbNumLba, > > > > + EFI_LBA_LIST_TERMINATOR); > > > > + if (EFI_ERROR (Status)) { > > > > + return Status; > > > > + } > > > > + > > > > + // Install all appropriate headers > > > > + Status =3D 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 !=3D NULL); > > > > + > > > > + Instance =3D AllocateCopyPool (sizeof (NOR_FLASH_INSTANCE), > > > > + &mNorFlashInstanceTemplate)= ; > > > > + if (Instance =3D=3D NULL) { > > > > + return EFI_OUT_OF_RESOURCES; > > > > + } > > > > + > > > > + Instance->DeviceBaseAddress =3D NorFlashDeviceBase; > > > > + Instance->RegionBaseAddress =3D NorFlashRegionBase; > > > > + Instance->Size =3D NorFlashSize; > > > > + > > > > + Instance->BlockSize =3D BlockSize; > > > > + Instance->LastBlock =3D (NorFlashSize / BlockSize)-1; > > > > + > > > > + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid)= ; > > > > + Instance->DevicePath.Index =3D (UINT8)Index; > > > > + > > > > + NorFlashReset (Instance); > > > > + > > > > + Instance->ShadowBuffer =3D AllocatePool (BlockSize);; > > > > + if (Instance->ShadowBuffer =3D=3D NULL) { > > > > + return EFI_OUT_OF_RESOURCES; > > > > + } > > > > + > > > > + if (SupportFvb) { > > > > + NorFlashFvbInitialize (Instance); > > > > + > > > > + //Install FirmwareVolumeBlock Protocol > > > > + Status =3D gMmst->MmInstallProtocolInterface ( > > > > + &Instance->Handle, > > > > + &gEfiSmmFirmwareVolumeBlockProtocolGuid, > > > > + EFI_NATIVE_INTERFACE, > > > > + &Instance->FvbProtocol > > > > + ); > > > > + if (EFI_ERROR (Status)) { > > > > + FreePool (Instance); > > > > + return Status; > > > > + } > > > > + } > > > > + > > > > + *NorFlashInstance =3D 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 =3D NorFlashPlatformInitialization (); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR, > > > > + "NorFlashInitialise: Fail to initialize Nor Flash devices\n= ")); > > > > + return Status; > > > > + } > > > > + > > > > + Status =3D NorFlashPlatformGetDevices (&NorFlashDevices, &mNorF= lashDeviceCount); > > > > + if (EFI_ERROR (Status)) { > > > > + DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flas= h devices\n")); > > > > + return Status; > > > > + } > > > > + > > > > + mNorFlashInstances =3D AllocatePool (sizeof (NOR_FLASH_INSTANCE= *) * mNorFlashDeviceCount); > > > > + > > > > + for (Index =3D 0; Index < mNorFlashDeviceCount; Index++) { > > > > + // Check if this NOR Flash device contain the variable storag= e region > > > > + ContainVariableStorage =3D > > > > + (NorFlashDevices[Index].RegionBaseAddress <=3D > > > > + PcdGet32 (PcdFlashNvStorageVariableBase)) && > > > > + (PcdGet32 (PcdFlashNvStorageVariableBase) + > > > > + PcdGet32 (PcdFlashNvStorageVariableSize) <=3D > > > > + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevic= es[Index].Size); > > > > + > > > > + Status =3D 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/NorFlashSta= ndaloneMm.inf b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandalon= eMm.inf > > > > new file mode 100644 > > > > index 0000000..12073fc > > > > --- /dev/null > > > > +++ b/Platform/ARM/Drivers/StandaloneMmNorFlash/NorFlashStandalone= Mm.inf > > > > @@ -0,0 +1,68 @@ > > > > +#/** @file > > > > +# > > > > +# Component description file for NorFlashStandaloneMm module > > > > +# > > > > +# 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 lic= ense 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 EXPR= ESS OR IMPLIED. > > > > +# > > > > +#**/ > > > > + > > > > +[Defines] > > > > + INF_VERSION =3D 0x00010005 > > > > + BASE_NAME =3D StandaloneMmNorFlash > > > > + FILE_GUID =3D 166F677B-DAC9-4AE4-AD34-2FF2= 504B0637 > > > > + MODULE_TYPE =3D MM_STANDALONE > > > > + VERSION_STRING =3D 1.0 > > > > + PI_SPECIFICATION_VERSION =3D 0x00010032 > > > > + ENTRY_POINT =3D 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 > > > > > > > >=20 >