From: "Sami Mujawar" <sami.mujawar@arm.com>
To: Ard Biesheuvel <ardb@kernel.org>, devel@edk2.groups.io
Cc: Leif Lindholm <quic_llindhol@quicinc.com>,
Thomas Abraham <thomas.abraham@arm.com>,
"nd@arm.com" <nd@arm.com>
Subject: Re: [PATCH edk2-platforms 3/4] Platform/ARM: clone NorFlashDxe from ArmPlatformPkg
Date: Wed, 19 Oct 2022 13:52:54 +0100 [thread overview]
Message-ID: <27c6db3f-4739-6f1b-d669-f051457122cf@arm.com> (raw)
In-Reply-To: <20221019103555.493477-4-ardb@kernel.org>
Hi Ard,
Thank you for this patch.
Reviewed-by: Sami Mujawar <sami.mujawar@arm.com>
Regards,
Sami Mujawar
On 19/10/2022 11:35 am, Ard Biesheuvel wrote:
> The ArmPlatformPkg version of NorFlashDxe and NorFlashStandaloneMm will
> be going away, so clone them into Platform/ARM where the ARM platforms
> that rely on this driver can keep using it.
>
> Other than updating the INF version, refreshing the file GUIDs and
> reorganizing the various INF sections, no changes have been made to the
> driver.
>
> Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
> ---
> Platform/ARM/ARM.dec | 4 +
> Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf | 71 ++
> Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf | 66 ++
> Platform/ARM/Drivers/NorFlashDxe/NorFlash.h | 422 +++++++++
> Platform/ARM/Drivers/NorFlashDxe/NorFlash.c | 991 ++++++++++++++++++++
> Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c | 123 +++
> Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c | 506 ++++++++++
> Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c | 777 +++++++++++++++
> Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c | 383 ++++++++
> 9 files changed, 3343 insertions(+)
>
> diff --git a/Platform/ARM/ARM.dec b/Platform/ARM/ARM.dec
> index cf1c8ef04742..be7e6dc83fde 100644
> --- a/Platform/ARM/ARM.dec
> +++ b/Platform/ARM/ARM.dec
> @@ -20,4 +20,8 @@ [LibraryClasses]
> NorFlashPlatformLib|Include/Library/NorFlashPlatformLib.h
>
>
>
> [Guids]
>
> + gPlatformArmTokenSpaceGuid = { 0x7a5e0def, 0xd3c3, 0x44f3, { 0x8d, 0x69, 0x70, 0xfc, 0x8f, 0xd6, 0x4f, 0xdf } }
>
> gArmBootMonFsFileInfoGuid = { 0x41e26b9c, 0xada6, 0x45b3, { 0x80, 0x8e, 0x23, 0x57, 0xa3, 0x5b, 0x60, 0xd6 } }
>
> +
>
> +[PcdsFeatureFlag.common]
>
> + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked|FALSE|BOOLEAN|0x0000001
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf
> new file mode 100644
> index 000000000000..cdf1f5c27f35
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.inf
> @@ -0,0 +1,71 @@
> +#/** @file
>
> +#
>
> +# Component description file for NorFlashDxe module
>
> +#
>
> +# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
>
> +#
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +#**/
>
> +
>
> +[Defines]
>
> + INF_VERSION = 1.29
>
> + BASE_NAME = NorFlashDxe
>
> + FILE_GUID = de6ae758-d662-4e17-a97c-4c5964da4c41
>
> + MODULE_TYPE = DXE_RUNTIME_DRIVER
>
> + VERSION_STRING = 1.0
>
> + ENTRY_POINT = NorFlashInitialise
>
> +
>
> +[Sources.common]
>
> + NorFlash.c
>
> + NorFlash.h
>
> + NorFlashBlockIoDxe.c
>
> + NorFlashDxe.c
>
> + NorFlashFvb.c
>
> +
>
> +[Packages]
>
> + EmbeddedPkg/EmbeddedPkg.dec
>
> + MdePkg/MdePkg.dec
>
> + MdeModulePkg/MdeModulePkg.dec
>
> + Platform/ARM/ARM.dec
>
> +
>
> +[LibraryClasses]
>
> + BaseLib
>
> + DebugLib
>
> + DxeServicesTableLib
>
> + HobLib
>
> + IoLib
>
> + NorFlashPlatformLib
>
> + UefiBootServicesTableLib
>
> + UefiDriverEntryPoint
>
> + UefiLib
>
> + UefiRuntimeLib
>
> +
>
> +[Guids]
>
> + gEdkiiNvVarStoreFormattedGuid ## PRODUCES ## PROTOCOL
>
> + gEfiAuthenticatedVariableGuid
>
> + gEfiEventVirtualAddressChangeGuid
>
> + gEfiSystemNvDataFvGuid
>
> + gEfiVariableGuid
>
> +
>
> +[Protocols]
>
> + gEfiBlockIoProtocolGuid
>
> + gEfiDevicePathProtocolGuid
>
> + gEfiDiskIoProtocolGuid
>
> + gEfiFirmwareVolumeBlockProtocolGuid
>
> +
>
> +[Pcd.common]
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
>
> +
>
> + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked
>
> +
>
> +[Depex]
>
> + gEfiCpuArchProtocolGuid
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf
> new file mode 100644
> index 000000000000..001f281220f2
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.inf
> @@ -0,0 +1,66 @@
> +#/** @file
>
> +#
>
> +# Component description file for NorFlashStandaloneMm module
>
> +#
>
> +# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
>
> +# Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>
>
> +#
>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +#
>
> +#**/
>
> +
>
> +[Defines]
>
> + INF_VERSION = 1.29
>
> + BASE_NAME = NorFlashStandaloneMm
>
> + FILE_GUID = a87c67d2-f183-415c-993d-11431fc478ee
>
> + MODULE_TYPE = MM_STANDALONE
>
> + VERSION_STRING = 1.0
>
> + PI_SPECIFICATION_VERSION = 0x00010032
>
> + ENTRY_POINT = NorFlashInitialise
>
> +
>
> +[Sources.common]
>
> + NorFlash.c
>
> + NorFlash.h
>
> + NorFlashFvb.c
>
> + NorFlashStandaloneMm.c
>
> +
>
> +[Packages]
>
> + EmbeddedPkg/EmbeddedPkg.dec
>
> + MdeModulePkg/MdeModulePkg.dec
>
> + MdePkg/MdePkg.dec
>
> + Platform/ARM/ARM.dec
>
> +
>
> +[LibraryClasses]
>
> + BaseLib
>
> + BaseMemoryLib
>
> + DebugLib
>
> + IoLib
>
> + MemoryAllocationLib
>
> + MmServicesTableLib
>
> + NorFlashPlatformLib
>
> + StandaloneMmDriverEntryPoint
>
> +
>
> +[Guids]
>
> + gEfiSystemNvDataFvGuid
>
> + gEfiVariableGuid
>
> + gEfiAuthenticatedVariableGuid
>
> +
>
> +[Protocols]
>
> + gEfiSmmFirmwareVolumeBlockProtocolGuid
>
> +
>
> +[FixedPcd]
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase
>
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
>
> +
>
> +[FeaturePcd]
>
> + gPlatformArmTokenSpaceGuid.PcdNorFlashCheckBlockLocked
>
> +
>
> +[Depex]
>
> + TRUE
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h
> new file mode 100644
> index 000000000000..c83032e87d9c
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.h
> @@ -0,0 +1,422 @@
> +/** @file NorFlash.h
>
> +
>
> + Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> +**/
>
> +
>
> +#ifndef __NOR_FLASH_H__
>
> +#define __NOR_FLASH_H__
>
> +
>
> +#include <Base.h>
>
> +#include <PiDxe.h>
>
> +
>
> +#include <Guid/EventGroup.h>
>
> +
>
> +#include <Protocol/BlockIo.h>
>
> +#include <Protocol/DiskIo.h>
>
> +#include <Protocol/FirmwareVolumeBlock.h>
>
> +
>
> +#include <Library/DebugLib.h>
>
> +#include <Library/IoLib.h>
>
> +#include <Library/NorFlashPlatformLib.h>
>
> +#include <Library/UefiLib.h>
>
> +#include <Library/UefiRuntimeLib.h>
>
> +
>
> +#define NOR_FLASH_ERASE_RETRY 10
>
> +
>
> +// Device access macros
>
> +// These are necessary because we use 2 x 16bit parts to make up 32bit data
>
> +
>
> +#define HIGH_16_BITS 0xFFFF0000
>
> +#define LOW_16_BITS 0x0000FFFF
>
> +#define LOW_8_BITS 0x000000FF
>
> +
>
> +#define FOLD_32BIT_INTO_16BIT(value) ( ( value >> 16 ) | ( value & LOW_16_BITS ) )
>
> +
>
> +#define GET_LOW_BYTE(value) ( value & LOW_8_BITS )
>
> +#define GET_HIGH_BYTE(value) ( GET_LOW_BYTE( value >> 16 ) )
>
> +
>
> +// Each command must be sent simultaneously to both chips,
>
> +// i.e. at the lower 16 bits AND at the higher 16 bits
>
> +#define CREATE_NOR_ADDRESS(BaseAddr, OffsetAddr) ((BaseAddr) + ((OffsetAddr) << 2))
>
> +#define CREATE_DUAL_CMD(Cmd) ( ( Cmd << 16) | ( Cmd & LOW_16_BITS) )
>
> +#define SEND_NOR_COMMAND(BaseAddr, Offset, Cmd) MmioWrite32 (CREATE_NOR_ADDRESS(BaseAddr,Offset), CREATE_DUAL_CMD(Cmd))
>
> +#define GET_NOR_BLOCK_ADDRESS(BaseAddr, Lba, LbaSize) ( BaseAddr + (UINTN)((Lba) * LbaSize) )
>
> +
>
> +// Status Register Bits
>
> +#define P30_SR_BIT_WRITE (BIT7 << 16 | BIT7)
>
> +#define P30_SR_BIT_ERASE_SUSPEND (BIT6 << 16 | BIT6)
>
> +#define P30_SR_BIT_ERASE (BIT5 << 16 | BIT5)
>
> +#define P30_SR_BIT_PROGRAM (BIT4 << 16 | BIT4)
>
> +#define P30_SR_BIT_VPP (BIT3 << 16 | BIT3)
>
> +#define P30_SR_BIT_PROGRAM_SUSPEND (BIT2 << 16 | BIT2)
>
> +#define P30_SR_BIT_BLOCK_LOCKED (BIT1 << 16 | BIT1)
>
> +#define P30_SR_BIT_BEFP (BIT0 << 16 | BIT0)
>
> +
>
> +// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family
>
> +
>
> +// On chip buffer size for buffered programming operations
>
> +// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each word is 2 bytes.
>
> +// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes
>
> +#define P30_MAX_BUFFER_SIZE_IN_BYTES ((UINTN)128)
>
> +#define P30_MAX_BUFFER_SIZE_IN_WORDS (P30_MAX_BUFFER_SIZE_IN_BYTES/((UINTN)4))
>
> +#define MAX_BUFFERED_PROG_ITERATIONS 10000000
>
> +#define BOUNDARY_OF_32_WORDS 0x7F
>
> +
>
> +// CFI Addresses
>
> +#define P30_CFI_ADDR_QUERY_UNIQUE_QRY 0x10
>
> +#define P30_CFI_ADDR_VENDOR_ID 0x13
>
> +
>
> +// CFI Data
>
> +#define CFI_QRY 0x00595251
>
> +
>
> +// READ Commands
>
> +#define P30_CMD_READ_DEVICE_ID 0x0090
>
> +#define P30_CMD_READ_STATUS_REGISTER 0x0070
>
> +#define P30_CMD_CLEAR_STATUS_REGISTER 0x0050
>
> +#define P30_CMD_READ_ARRAY 0x00FF
>
> +#define P30_CMD_READ_CFI_QUERY 0x0098
>
> +
>
> +// WRITE Commands
>
> +#define P30_CMD_WORD_PROGRAM_SETUP 0x0040
>
> +#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP 0x0010
>
> +#define P30_CMD_BUFFERED_PROGRAM_SETUP 0x00E8
>
> +#define P30_CMD_BUFFERED_PROGRAM_CONFIRM 0x00D0
>
> +#define P30_CMD_BEFP_SETUP 0x0080
>
> +#define P30_CMD_BEFP_CONFIRM 0x00D0
>
> +
>
> +// ERASE Commands
>
> +#define P30_CMD_BLOCK_ERASE_SETUP 0x0020
>
> +#define P30_CMD_BLOCK_ERASE_CONFIRM 0x00D0
>
> +
>
> +// SUSPEND Commands
>
> +#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND 0x00B0
>
> +#define P30_CMD_SUSPEND_RESUME 0x00D0
>
> +
>
> +// BLOCK LOCKING / UNLOCKING Commands
>
> +#define P30_CMD_LOCK_BLOCK_SETUP 0x0060
>
> +#define P30_CMD_LOCK_BLOCK 0x0001
>
> +#define P30_CMD_UNLOCK_BLOCK 0x00D0
>
> +#define P30_CMD_LOCK_DOWN_BLOCK 0x002F
>
> +
>
> +// PROTECTION Commands
>
> +#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0
>
> +
>
> +// CONFIGURATION Commands
>
> +#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060
>
> +#define P30_CMD_READ_CONFIGURATION_REGISTER 0x0003
>
> +
>
> +#define NOR_FLASH_SIGNATURE SIGNATURE_32('n', 'o', 'r', '0')
>
> +#define INSTANCE_FROM_FVB_THIS(a) CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE)
>
> +#define INSTANCE_FROM_BLKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE)
>
> +#define INSTANCE_FROM_DISKIO_THIS(a) CR(a, NOR_FLASH_INSTANCE, DiskIoProtocol, NOR_FLASH_SIGNATURE)
>
> +
>
> +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE;
>
> +
>
> +#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;
>
> + EFI_LBA StartLba;
>
> +
>
> + EFI_BLOCK_IO_PROTOCOL BlockIoProtocol;
>
> + EFI_BLOCK_IO_MEDIA Media;
>
> + EFI_DISK_IO_PROTOCOL DiskIoProtocol;
>
> +
>
> + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;
>
> + VOID *ShadowBuffer;
>
> +
>
> + NOR_FLASH_DEVICE_PATH DevicePath;
>
> +};
>
> +
>
> +EFI_STATUS
>
> +NorFlashReadCfiData (
>
> + IN UINTN DeviceBaseAddress,
>
> + IN UINTN CFI_Offset,
>
> + IN UINT32 NumberOfBytes,
>
> + OUT UINT32 *Data
>
> + );
>
> +
>
> +EFI_STATUS
>
> +NorFlashWriteBuffer (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN TargetAddress,
>
> + IN UINTN BufferSizeInBytes,
>
> + IN UINT32 *Buffer
>
> + );
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoReset (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN BOOLEAN ExtendedVerification
>
> + );
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoReadBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + OUT VOID *Buffer
>
> + );
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoWriteBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + IN VOID *Buffer
>
> + );
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoFlushBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This
>
> + );
>
> +
>
> +//
>
> +// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.ReadDisk
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashDiskIoReadDisk (
>
> + IN EFI_DISK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN UINT64 Offset,
>
> + IN UINTN BufferSize,
>
> + OUT VOID *Buffer
>
> + );
>
> +
>
> +//
>
> +// DiskIO Protocol function EFI_DISK_IO_PROTOCOL.WriteDisk
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashDiskIoWriteDisk (
>
> + IN EFI_DISK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN UINT64 Offset,
>
> + IN UINTN BufferSize,
>
> + IN VOID *Buffer
>
> + );
>
> +
>
> +//
>
> +// NorFlashFvbDxe.c
>
> +//
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetAttributes (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + OUT EFI_FVB_ATTRIBUTES_2 *Attributes
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbSetAttributes (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetPhysicalAddress (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + OUT EFI_PHYSICAL_ADDRESS *Address
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetBlockSize (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + OUT UINTN *BlockSize,
>
> + OUT UINTN *NumberOfBlocks
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbRead (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN OUT UINTN *NumBytes,
>
> + IN OUT UINT8 *Buffer
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbWrite (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN OUT UINTN *NumBytes,
>
> + IN UINT8 *Buffer
>
> + );
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbEraseBlocks (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + ...
>
> + );
>
> +
>
> +EFI_STATUS
>
> +ValidateFvHeader (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + );
>
> +
>
> +EFI_STATUS
>
> +InitializeFvAndVariableStoreHeaders (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + );
>
> +
>
> +VOID
>
> +EFIAPI
>
> +FvbVirtualNotifyEvent (
>
> + IN EFI_EVENT Event,
>
> + IN VOID *Context
>
> + );
>
> +
>
> +//
>
> +// NorFlashDxe.c
>
> +//
>
> +
>
> +EFI_STATUS
>
> +NorFlashWriteFullBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN EFI_LBA Lba,
>
> + IN UINT32 *DataBuffer,
>
> + IN UINT32 BlockSizeInWords
>
> + );
>
> +
>
> +EFI_STATUS
>
> +NorFlashUnlockAndEraseSingleBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + );
>
> +
>
> +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
>
> + );
>
> +
>
> +//
>
> +// NorFlash.c
>
> +//
>
> +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
>
> + );
>
> +
>
> +EFI_STATUS
>
> +NorFlashEraseSingleBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + );
>
> +
>
> +EFI_STATUS
>
> +NorFlashUnlockSingleBlockIfNecessary (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + );
>
> +
>
> +EFI_STATUS
>
> +NorFlashWriteSingleWord (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN WordAddress,
>
> + IN UINT32 WriteData
>
> + );
>
> +
>
> +VOID
>
> +EFIAPI
>
> +NorFlashVirtualNotifyEvent (
>
> + IN EFI_EVENT Event,
>
> + IN VOID *Context
>
> + );
>
> +
>
> +#endif /* __NOR_FLASH_H__ */
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c
> new file mode 100644
> index 000000000000..1b431073ee93
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlash.c
> @@ -0,0 +1,991 @@
> +/** @file NorFlash.c
>
> +
>
> + Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR>
>
> + Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> +**/
>
> +
>
> +#include <Library/BaseMemoryLib.h>
>
> +
>
> +#include "NorFlash.h"
>
> +
>
> +//
>
> +// Global variable declarations
>
> +//
>
> +extern NOR_FLASH_INSTANCE **mNorFlashInstances;
>
> +extern UINT32 mNorFlashDeviceCount;
>
> +
>
> +UINT32
>
> +NorFlashReadStatusRegister (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN SR_Address
>
> + )
>
> +{
>
> + // Prepare to read the status register
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);
>
> + return MmioRead32 (Instance->DeviceBaseAddress);
>
> +}
>
> +
>
> +STATIC
>
> +BOOLEAN
>
> +NorFlashBlockIsLocked (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + )
>
> +{
>
> + UINT32 LockStatus;
>
> +
>
> + // Send command for reading device id
>
> + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
>
> +
>
> + // Read block lock status
>
> + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));
>
> +
>
> + // Decode block lock status
>
> + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);
>
> +
>
> + if ((LockStatus & 0x2) != 0) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));
>
> + }
>
> +
>
> + return ((LockStatus & 0x1) != 0);
>
> +}
>
> +
>
> +STATIC
>
> +EFI_STATUS
>
> +NorFlashUnlockSingleBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + )
>
> +{
>
> + UINT32 LockStatus;
>
> +
>
> + // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations
>
> + // and to protect shared data structures.
>
> +
>
> + if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {
>
> + do {
>
> + // Request a lock setup
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
>
> +
>
> + // Request an unlock
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
>
> +
>
> + // Send command for reading device id
>
> + SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
>
> +
>
> + // Read block lock status
>
> + LockStatus = MmioRead32 (CREATE_NOR_ADDRESS (BlockAddress, 2));
>
> +
>
> + // Decode block lock status
>
> + LockStatus = FOLD_32BIT_INTO_16BIT (LockStatus);
>
> + } while ((LockStatus & 0x1) == 1);
>
> + } else {
>
> + // Request a lock setup
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
>
> +
>
> + // Request an unlock
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
>
> +
>
> + // Wait until the status register gives us the all clear
>
> + do {
>
> + LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);
>
> + } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
>
> + }
>
> +
>
> + // Put device back into Read Array mode
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x\n", BlockAddress));
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashUnlockSingleBlockIfNecessary (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + if (NorFlashBlockIsLocked (Instance, BlockAddress)) {
>
> + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +/**
>
> + * The following function presumes that the block has already been unlocked.
>
> + **/
>
> +EFI_STATUS
>
> +NorFlashEraseSingleBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN BlockAddress
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 StatusRegister;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // Request a block erase and then confirm it
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);
>
> + SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);
>
> +
>
> + // Wait until the status register gives us the all clear
>
> + do {
>
> + StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);
>
> + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
>
> +
>
> + if (StatusRegister & P30_SR_BIT_VPP) {
>
> + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {
>
> + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_ERASE) {
>
> + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
>
> + // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...
>
> + DEBUG ((DEBUG_INFO, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));
>
> + Status = EFI_WRITE_PROTECTED;
>
> + }
>
> +
>
> + if (EFI_ERROR (Status)) {
>
> + // Clear the Status Register
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
>
> + }
>
> +
>
> + // Put device back into Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashWriteSingleWord (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN WordAddress,
>
> + IN UINT32 WriteData
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 StatusRegister;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // Request a write single word command
>
> + SEND_NOR_COMMAND (WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);
>
> +
>
> + // Store the word into NOR Flash;
>
> + MmioWrite32 (WordAddress, WriteData);
>
> +
>
> + // Wait for the write to complete and then check for any errors; i.e. check the Status Register
>
> + do {
>
> + // Prepare to read the status register
>
> + StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);
>
> + // The chip is busy while the WRITE bit is not asserted
>
> + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
>
> +
>
> + // Perform a full status check:
>
> + // Mask the relevant bits of Status Register.
>
> + // Everything should be zero, if not, we have a problem
>
> +
>
> + if (StatusRegister & P30_SR_BIT_VPP) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n", WordAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_PROGRAM) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n", WordAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n", WordAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (!EFI_ERROR (Status)) {
>
> + // Clear the Status Register
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
>
> + }
>
> +
>
> + // Put device back into Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +/*
>
> + * Writes data to the NOR Flash using the Buffered Programming method.
>
> + *
>
> + * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.
>
> + * Therefore this function will only handle buffers up to 32 words or 128 bytes.
>
> + * To deal with larger buffers, call this function again.
>
> + *
>
> + * This function presumes that both the TargetAddress and the TargetAddress+BufferSize
>
> + * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.
>
> + *
>
> + * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,
>
> + * then programming time is doubled and power consumption is increased.
>
> + * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.
>
> + * i.e. the last 4 bits of the target start address must be zero: 0x......00
>
> + */
>
> +EFI_STATUS
>
> +NorFlashWriteBuffer (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN UINTN TargetAddress,
>
> + IN UINTN BufferSizeInBytes,
>
> + IN UINT32 *Buffer
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINTN BufferSizeInWords;
>
> + UINTN Count;
>
> + volatile UINT32 *Data;
>
> + UINTN WaitForBuffer;
>
> + BOOLEAN BufferAvailable;
>
> + UINT32 StatusRegister;
>
> +
>
> + WaitForBuffer = MAX_BUFFERED_PROG_ITERATIONS;
>
> + BufferAvailable = FALSE;
>
> +
>
> + // Check that the target address does not cross a 32-word boundary.
>
> + if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Check there are some data to program
>
> + if (BufferSizeInBytes == 0) {
>
> + return EFI_BUFFER_TOO_SMALL;
>
> + }
>
> +
>
> + // Check that the buffer size does not exceed the maximum hardware buffer size on chip.
>
> + if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // Check that the buffer size is a multiple of 32-bit words
>
> + if ((BufferSizeInBytes % 4) != 0) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // Pre-programming conditions checked, now start the algorithm.
>
> +
>
> + // Prepare the data destination address
>
> + Data = (UINT32 *)TargetAddress;
>
> +
>
> + // Check the availability of the buffer
>
> + do {
>
> + // Issue the Buffered Program Setup command
>
> + SEND_NOR_COMMAND (TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);
>
> +
>
> + // Read back the status register bit#7 from the same address
>
> + if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {
>
> + BufferAvailable = TRUE;
>
> + }
>
> +
>
> + // Update the loop counter
>
> + WaitForBuffer--;
>
> + } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));
>
> +
>
> + // The buffer was not available for writing
>
> + if (WaitForBuffer == 0) {
>
> + Status = EFI_DEVICE_ERROR;
>
> + goto EXIT;
>
> + }
>
> +
>
> + // From now on we work in 32-bit words
>
> + BufferSizeInWords = BufferSizeInBytes / (UINTN)4;
>
> +
>
> + // Write the word count, which is (buffer_size_in_words - 1),
>
> + // because word count 0 means one word.
>
> + SEND_NOR_COMMAND (TargetAddress, 0, (BufferSizeInWords - 1));
>
> +
>
> + // Write the data to the NOR Flash, advancing each address by 4 bytes
>
> + for (Count = 0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {
>
> + MmioWrite32 ((UINTN)Data, *Buffer);
>
> + }
>
> +
>
> + // Issue the Buffered Program Confirm command, to start the programming operation
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);
>
> +
>
> + // Wait for the write to complete and then check for any errors; i.e. check the Status Register
>
> + do {
>
> + StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);
>
> + // The chip is busy while the WRITE bit is not asserted
>
> + } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
>
> +
>
> + // Perform a full status check:
>
> + // Mask the relevant bits of Status Register.
>
> + // Everything should be zero, if not, we have a problem
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + if (StatusRegister & P30_SR_BIT_VPP) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_PROGRAM) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n", TargetAddress));
>
> + Status = EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + if (!EFI_ERROR (Status)) {
>
> + // Clear the Status Register
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
>
> + }
>
> +
>
> +EXIT:
>
> + // Put device back into Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashWriteBlocks (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + IN VOID *Buffer
>
> + )
>
> +{
>
> + UINT32 *pWriteBuffer;
>
> + EFI_STATUS Status;
>
> + EFI_LBA CurrentBlock;
>
> + UINT32 BlockSizeInWords;
>
> + UINT32 NumBlocks;
>
> + UINT32 BlockCount;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // The buffer must be valid
>
> + if (Buffer == NULL) {
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + if (Instance->Media.ReadOnly == TRUE) {
>
> + return EFI_WRITE_PROTECTED;
>
> + }
>
> +
>
> + // We must have some bytes to read
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));
>
> + if (BufferSizeInBytes == 0) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // The size of the buffer must be a multiple of the block size
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));
>
> + if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // All blocks must be within the device
>
> + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));
>
> +
>
> + if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + BlockSizeInWords = Instance->Media.BlockSize / 4;
>
> +
>
> + // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer
>
> + // to a proper data type, so use *ReadBuffer
>
> + pWriteBuffer = (UINT32 *)Buffer;
>
> +
>
> + CurrentBlock = Lba;
>
> + for (BlockCount = 0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));
>
> +
>
> + Status = NorFlashWriteFullBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);
>
> +
>
> + if (EFI_ERROR (Status)) {
>
> + break;
>
> + }
>
> + }
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));
>
> + return Status;
>
> +}
>
> +
>
> +#define BOTH_ALIGNED(a, b, align) ((((UINTN)(a) | (UINTN)(b)) & ((align) - 1)) == 0)
>
> +
>
> +/**
>
> + Copy Length bytes from Source to Destination, using aligned accesses only.
>
> + Note that this implementation uses memcpy() semantics rather then memmove()
>
> + semantics, i.e., SourceBuffer and DestinationBuffer should not overlap.
>
> +
>
> + @param DestinationBuffer The target of the copy request.
>
> + @param SourceBuffer The place to copy from.
>
> + @param Length The number of bytes to copy.
>
> +
>
> + @return Destination
>
> +
>
> +**/
>
> +STATIC
>
> +VOID *
>
> +AlignedCopyMem (
>
> + OUT VOID *DestinationBuffer,
>
> + IN CONST VOID *SourceBuffer,
>
> + IN UINTN Length
>
> + )
>
> +{
>
> + UINT8 *Destination8;
>
> + CONST UINT8 *Source8;
>
> + UINT32 *Destination32;
>
> + CONST UINT32 *Source32;
>
> + UINT64 *Destination64;
>
> + CONST UINT64 *Source64;
>
> +
>
> + if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 8) && (Length >= 8)) {
>
> + Destination64 = DestinationBuffer;
>
> + Source64 = SourceBuffer;
>
> + while (Length >= 8) {
>
> + *Destination64++ = *Source64++;
>
> + Length -= 8;
>
> + }
>
> +
>
> + Destination8 = (UINT8 *)Destination64;
>
> + Source8 = (CONST UINT8 *)Source64;
>
> + } else if (BOTH_ALIGNED (DestinationBuffer, SourceBuffer, 4) && (Length >= 4)) {
>
> + Destination32 = DestinationBuffer;
>
> + Source32 = SourceBuffer;
>
> + while (Length >= 4) {
>
> + *Destination32++ = *Source32++;
>
> + Length -= 4;
>
> + }
>
> +
>
> + Destination8 = (UINT8 *)Destination32;
>
> + Source8 = (CONST UINT8 *)Source32;
>
> + } else {
>
> + Destination8 = DestinationBuffer;
>
> + Source8 = SourceBuffer;
>
> + }
>
> +
>
> + while (Length-- != 0) {
>
> + *Destination8++ = *Source8++;
>
> + }
>
> +
>
> + return DestinationBuffer;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashReadBlocks (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + OUT VOID *Buffer
>
> + )
>
> +{
>
> + UINT32 NumBlocks;
>
> + UINTN StartAddress;
>
> +
>
> + DEBUG ((
>
> + DEBUG_BLKIO,
>
> + "NorFlashReadBlocks: BufferSize=0x%xB BlockSize=0x%xB LastBlock=%ld, Lba=%ld.\n",
>
> + BufferSizeInBytes,
>
> + Instance->Media.BlockSize,
>
> + Instance->Media.LastBlock,
>
> + Lba
>
> + ));
>
> +
>
> + // The buffer must be valid
>
> + if (Buffer == NULL) {
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Return if we have not any byte to read
>
> + if (BufferSizeInBytes == 0) {
>
> + return EFI_SUCCESS;
>
> + }
>
> +
>
> + // The size of the buffer must be a multiple of the block size
>
> + if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // All blocks must be within the device
>
> + NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize;
>
> +
>
> + if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Get the address to start reading from
>
> + StartAddress = GET_NOR_BLOCK_ADDRESS (
>
> + Instance->RegionBaseAddress,
>
> + Lba,
>
> + Instance->Media.BlockSize
>
> + );
>
> +
>
> + // Put the device into Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + // Readout the data
>
> + AlignedCopyMem (Buffer, (VOID *)StartAddress, BufferSizeInBytes);
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashRead (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN UINTN BufferSizeInBytes,
>
> + OUT VOID *Buffer
>
> + )
>
> +{
>
> + UINTN StartAddress;
>
> +
>
> + // The buffer must be valid
>
> + if (Buffer == NULL) {
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Return if we have not any byte to read
>
> + if (BufferSizeInBytes == 0) {
>
> + return EFI_SUCCESS;
>
> + }
>
> +
>
> + if (((Lba * Instance->Media.BlockSize) + Offset + BufferSizeInBytes) > Instance->Size) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashRead: ERROR - Read will exceed device size.\n"));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Get the address to start reading from
>
> + StartAddress = GET_NOR_BLOCK_ADDRESS (
>
> + Instance->RegionBaseAddress,
>
> + Lba,
>
> + Instance->Media.BlockSize
>
> + );
>
> +
>
> + // Put the device into Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> +
>
> + // Readout the data
>
> + AlignedCopyMem (Buffer, (VOID *)(StartAddress + Offset), BufferSizeInBytes);
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/*
>
> + Write a full or portion of a block. It must not span block boundaries; that is,
>
> + Offset + *NumBytes <= Instance->Media.BlockSize.
>
> +*/
>
> +EFI_STATUS
>
> +NorFlashWriteSingleBlock (
>
> + IN NOR_FLASH_INSTANCE *Instance,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN OUT UINTN *NumBytes,
>
> + IN UINT8 *Buffer
>
> + )
>
> +{
>
> + EFI_STATUS TempStatus;
>
> + UINT32 Tmp;
>
> + UINT32 TmpBuf;
>
> + UINT32 WordToWrite;
>
> + UINT32 Mask;
>
> + BOOLEAN DoErase;
>
> + UINTN BytesToWrite;
>
> + UINTN CurOffset;
>
> + UINTN WordAddr;
>
> + UINTN BlockSize;
>
> + UINTN BlockAddress;
>
> + UINTN PrevBlockAddress;
>
> +
>
> + PrevBlockAddress = 0;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashWriteSingleBlock(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Lba, Offset, *NumBytes, Buffer));
>
> +
>
> + // Detect WriteDisabled state
>
> + if (Instance->Media.ReadOnly == TRUE) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - Can not write: Device is in WriteDisabled state.\n"));
>
> + // It is in WriteDisabled state, return an error right away
>
> + return EFI_ACCESS_DENIED;
>
> + }
>
> +
>
> + // Cache the block size to avoid de-referencing pointers all the time
>
> + BlockSize = Instance->Media.BlockSize;
>
> +
>
> + // The write must not span block boundaries.
>
> + // We need to check each variable individually because adding two large values together overflows.
>
> + if ((Offset >= BlockSize) ||
>
> + (*NumBytes > BlockSize) ||
>
> + ((Offset + *NumBytes) > BlockSize))
>
> + {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // We must have some bytes to write
>
> + if (*NumBytes == 0) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashWriteSingleBlock: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // Pick 128bytes as a good start for word operations as opposed to erasing the
>
> + // block and writing the data regardless if an erase is really needed.
>
> + // It looks like most individual NV variable writes are smaller than 128bytes.
>
> + if (*NumBytes <= 128) {
>
> + // Check to see if we need to erase before programming the data into NOR.
>
> + // If the destination bits are only changing from 1s to 0s we can just write.
>
> + // After a block is erased all bits in the block is set to 1.
>
> + // If any byte requires us to erase we just give up and rewrite all of it.
>
> + DoErase = FALSE;
>
> + BytesToWrite = *NumBytes;
>
> + CurOffset = Offset;
>
> +
>
> + while (BytesToWrite > 0) {
>
> + // Read full word from NOR, splice as required. A word is the smallest
>
> + // unit we can write.
>
> + TempStatus = NorFlashRead (Instance, Lba, CurOffset & ~(0x3), sizeof (Tmp), &Tmp);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + // Physical address of word in NOR to write.
>
> + WordAddr = (CurOffset & ~(0x3)) + GET_NOR_BLOCK_ADDRESS (
>
> + Instance->RegionBaseAddress,
>
> + Lba,
>
> + BlockSize
>
> + );
>
> + // The word of data that is to be written.
>
> + TmpBuf = *((UINT32 *)(Buffer + (*NumBytes - BytesToWrite)));
>
> +
>
> + // First do word aligned chunks.
>
> + if ((CurOffset & 0x3) == 0) {
>
> + if (BytesToWrite >= 4) {
>
> + // Is the destination still in 'erased' state?
>
> + if (~Tmp != 0) {
>
> + // Check to see if we are only changing bits to zero.
>
> + if ((Tmp ^ TmpBuf) & TmpBuf) {
>
> + DoErase = TRUE;
>
> + break;
>
> + }
>
> + }
>
> +
>
> + // Write this word to NOR
>
> + WordToWrite = TmpBuf;
>
> + CurOffset += sizeof (TmpBuf);
>
> + BytesToWrite -= sizeof (TmpBuf);
>
> + } else {
>
> + // BytesToWrite < 4. Do small writes and left-overs
>
> + Mask = ~((~0) << (BytesToWrite * 8));
>
> + // Mask out the bytes we want.
>
> + TmpBuf &= Mask;
>
> + // Is the destination still in 'erased' state?
>
> + if ((Tmp & Mask) != Mask) {
>
> + // Check to see if we are only changing bits to zero.
>
> + if ((Tmp ^ TmpBuf) & TmpBuf) {
>
> + DoErase = TRUE;
>
> + break;
>
> + }
>
> + }
>
> +
>
> + // Merge old and new data. Write merged word to NOR
>
> + WordToWrite = (Tmp & ~Mask) | TmpBuf;
>
> + CurOffset += BytesToWrite;
>
> + BytesToWrite = 0;
>
> + }
>
> + } else {
>
> + // Do multiple words, but starting unaligned.
>
> + if (BytesToWrite > (4 - (CurOffset & 0x3))) {
>
> + Mask = ((~0) << ((CurOffset & 0x3) * 8));
>
> + // Mask out the bytes we want.
>
> + TmpBuf &= Mask;
>
> + // Is the destination still in 'erased' state?
>
> + if ((Tmp & Mask) != Mask) {
>
> + // Check to see if we are only changing bits to zero.
>
> + if ((Tmp ^ TmpBuf) & TmpBuf) {
>
> + DoErase = TRUE;
>
> + break;
>
> + }
>
> + }
>
> +
>
> + // Merge old and new data. Write merged word to NOR
>
> + WordToWrite = (Tmp & ~Mask) | TmpBuf;
>
> + BytesToWrite -= (4 - (CurOffset & 0x3));
>
> + CurOffset += (4 - (CurOffset & 0x3));
>
> + } else {
>
> + // Unaligned and fits in one word.
>
> + Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8);
>
> + // Mask out the bytes we want.
>
> + TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask;
>
> + // Is the destination still in 'erased' state?
>
> + if ((Tmp & Mask) != Mask) {
>
> + // Check to see if we are only changing bits to zero.
>
> + if ((Tmp ^ TmpBuf) & TmpBuf) {
>
> + DoErase = TRUE;
>
> + break;
>
> + }
>
> + }
>
> +
>
> + // Merge old and new data. Write merged word to NOR
>
> + WordToWrite = (Tmp & ~Mask) | TmpBuf;
>
> + CurOffset += BytesToWrite;
>
> + BytesToWrite = 0;
>
> + }
>
> + }
>
> +
>
> + //
>
> + // Write the word to NOR.
>
> + //
>
> +
>
> + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSize);
>
> + if (BlockAddress != PrevBlockAddress) {
>
> + TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + PrevBlockAddress = BlockAddress;
>
> + }
>
> +
>
> + TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> + }
>
> +
>
> + // Exit if we got here and could write all the data. Otherwise do the
>
> + // Erase-Write cycle.
>
> + if (!DoErase) {
>
> + return EFI_SUCCESS;
>
> + }
>
> + }
>
> +
>
> + // Check we did get some memory. Buffer is BlockSize.
>
> + if (Instance->ShadowBuffer == NULL) {
>
> + DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + // Read NOR Flash data into shadow buffer
>
> + TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + // Return one of the pre-approved error statuses
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + // Put the data at the appropriate location inside the buffer area
>
> + CopyMem ((VOID *)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);
>
> +
>
> + // Write the modified buffer back to the NorFlash
>
> + TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize, Instance->ShadowBuffer);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + // Return one of the pre-approved error statuses
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/*
>
> + Although DiskIoDxe will automatically install the DiskIO protocol whenever
>
> + we install the BlockIO protocol, its implementation is sub-optimal as it reads
>
> + and writes entire blocks using the BlockIO protocol. In fact we can access
>
> + NOR flash with a finer granularity than that, so we can improve performance
>
> + by directly producing the DiskIO protocol.
>
> +*/
>
> +
>
> +/**
>
> + Read BufferSize bytes from Offset into Buffer.
>
> +
>
> + @param This Protocol instance pointer.
>
> + @param MediaId Id of the media, changes every time the media is replaced.
>
> + @param Offset The starting byte offset to read from
>
> + @param BufferSize Size of Buffer
>
> + @param Buffer Buffer containing read data
>
> +
>
> + @retval EFI_SUCCESS The data was read correctly from the device.
>
> + @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
>
> + @retval EFI_NO_MEDIA There is no media in the device.
>
> + @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.
>
> + @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
>
> + valid for the device.
>
> +
>
> +**/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashDiskIoReadDisk (
>
> + IN EFI_DISK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN UINT64 DiskOffset,
>
> + IN UINTN BufferSize,
>
> + OUT VOID *Buffer
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> + UINT32 BlockSize;
>
> + UINT32 BlockOffset;
>
> + EFI_LBA Lba;
>
> +
>
> + Instance = INSTANCE_FROM_DISKIO_THIS (This);
>
> +
>
> + if (MediaId != Instance->Media.MediaId) {
>
> + return EFI_MEDIA_CHANGED;
>
> + }
>
> +
>
> + BlockSize = Instance->Media.BlockSize;
>
> + Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);
>
> +
>
> + return NorFlashRead (Instance, Lba, BlockOffset, BufferSize, Buffer);
>
> +}
>
> +
>
> +/**
>
> + Writes a specified number of bytes to a device.
>
> +
>
> + @param This Indicates a pointer to the calling context.
>
> + @param MediaId ID of the medium to be written.
>
> + @param Offset The starting byte offset on the logical block I/O device to write.
>
> + @param BufferSize The size in bytes of Buffer. The number of bytes to write to the device.
>
> + @param Buffer A pointer to the buffer containing the data to be written.
>
> +
>
> + @retval EFI_SUCCESS The data was written correctly to the device.
>
> + @retval EFI_WRITE_PROTECTED The device can not be written to.
>
> + @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
>
> + @retval EFI_NO_MEDIA There is no media in the device.
>
> + @retval EFI_MEDIA_CHANGED The MediaId does not match the current device.
>
> + @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
>
> + valid for the device.
>
> +
>
> +**/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashDiskIoWriteDisk (
>
> + IN EFI_DISK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN UINT64 DiskOffset,
>
> + IN UINTN BufferSize,
>
> + IN VOID *Buffer
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> + UINT32 BlockSize;
>
> + UINT32 BlockOffset;
>
> + EFI_LBA Lba;
>
> + UINTN RemainingBytes;
>
> + UINTN WriteSize;
>
> + EFI_STATUS Status;
>
> +
>
> + Instance = INSTANCE_FROM_DISKIO_THIS (This);
>
> +
>
> + if (MediaId != Instance->Media.MediaId) {
>
> + return EFI_MEDIA_CHANGED;
>
> + }
>
> +
>
> + BlockSize = Instance->Media.BlockSize;
>
> + Lba = (EFI_LBA)DivU64x32Remainder (DiskOffset, BlockSize, &BlockOffset);
>
> +
>
> + RemainingBytes = BufferSize;
>
> +
>
> + // Write either all the remaining bytes, or the number of bytes that bring
>
> + // us up to a block boundary, whichever is less.
>
> + // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next
>
> + // block boundary (even if it is already on one).
>
> + WriteSize = MIN (RemainingBytes, ((DiskOffset | (BlockSize - 1)) + 1) - DiskOffset);
>
> +
>
> + do {
>
> + if (WriteSize == BlockSize) {
>
> + // Write a full block
>
> + Status = NorFlashWriteFullBlock (Instance, Lba, Buffer, BlockSize / sizeof (UINT32));
>
> + } else {
>
> + // Write a partial block
>
> + Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize, Buffer);
>
> + }
>
> +
>
> + if (EFI_ERROR (Status)) {
>
> + return Status;
>
> + }
>
> +
>
> + // Now continue writing either all the remaining bytes or single blocks.
>
> + RemainingBytes -= WriteSize;
>
> + Buffer = (UINT8 *)Buffer + WriteSize;
>
> + Lba++;
>
> + BlockOffset = 0;
>
> + WriteSize = MIN (RemainingBytes, BlockSize);
>
> + } while (RemainingBytes);
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +NorFlashReset (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + )
>
> +{
>
> + // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode
>
> + SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/**
>
> + Fixup internal data so that EFI can be call in virtual mode.
>
> + Call the passed in Child Notify event and convert any pointers in
>
> + lib to virtual mode.
>
> +
>
> + @param[in] Event The Event that is being processed
>
> + @param[in] Context Event Context
>
> +**/
>
> +VOID
>
> +EFIAPI
>
> +NorFlashVirtualNotifyEvent (
>
> + IN EFI_EVENT Event,
>
> + IN VOID *Context
>
> + )
>
> +{
>
> + UINTN Index;
>
> +
>
> + for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->DeviceBaseAddress);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->RegionBaseAddress);
>
> +
>
> + // Convert BlockIo protocol
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.FlushBlocks);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.ReadBlocks);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.Reset);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->BlockIoProtocol.WriteBlocks);
>
> +
>
> + // Convert Fvb
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.EraseBlocks);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetAttributes);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetBlockSize);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.GetPhysicalAddress);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Read);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.SetAttributes);
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->FvbProtocol.Write);
>
> +
>
> + if (mNorFlashInstances[Index]->ShadowBuffer != NULL) {
>
> + EfiConvertPointer (0x0, (VOID **)&mNorFlashInstances[Index]->ShadowBuffer);
>
> + }
>
> + }
>
> +
>
> + return;
>
> +}
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c
> new file mode 100644
> index 000000000000..9d4732c6905a
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c
> @@ -0,0 +1,123 @@
> +/** @file NorFlashBlockIoDxe.c
>
> +
>
> + Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> +**/
>
> +
>
> +#include <Library/BaseMemoryLib.h>
>
> +#include <Library/UefiBootServicesTableLib.h>
>
> +
>
> +#include "NorFlash.h"
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoReset (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN BOOLEAN ExtendedVerification
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_BLKIO_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReset(MediaId=0x%x)\n", This->Media->MediaId));
>
> +
>
> + return NorFlashReset (Instance);
>
> +}
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoReadBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + OUT VOID *Buffer
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> + EFI_STATUS Status;
>
> + EFI_BLOCK_IO_MEDIA *Media;
>
> +
>
> + if (This == NULL) {
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + Instance = INSTANCE_FROM_BLKIO_THIS (This);
>
> + Media = This->Media;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReadBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, BufferSizeInBytes, Buffer));
>
> +
>
> + if (!Media) {
>
> + Status = EFI_INVALID_PARAMETER;
>
> + } else if (!Media->MediaPresent) {
>
> + Status = EFI_NO_MEDIA;
>
> + } else if (Media->MediaId != MediaId) {
>
> + Status = EFI_MEDIA_CHANGED;
>
> + } else if ((Media->IoAlign > 2) && (((UINTN)Buffer & (Media->IoAlign - 1)) != 0)) {
>
> + Status = EFI_INVALID_PARAMETER;
>
> + } else {
>
> + Status = NorFlashReadBlocks (Instance, Lba, BufferSizeInBytes, Buffer);
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoWriteBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This,
>
> + IN UINT32 MediaId,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN BufferSizeInBytes,
>
> + IN VOID *Buffer
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> + EFI_STATUS Status;
>
> +
>
> + Instance = INSTANCE_FROM_BLKIO_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes, BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));
>
> +
>
> + if ( !This->Media->MediaPresent ) {
>
> + Status = EFI_NO_MEDIA;
>
> + } else if ( This->Media->MediaId != MediaId ) {
>
> + Status = EFI_MEDIA_CHANGED;
>
> + } else if ( This->Media->ReadOnly ) {
>
> + Status = EFI_WRITE_PROTECTED;
>
> + } else {
>
> + Status = NorFlashWriteBlocks (Instance, Lba, BufferSizeInBytes, Buffer);
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +//
>
> +// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks
>
> +//
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashBlockIoFlushBlocks (
>
> + IN EFI_BLOCK_IO_PROTOCOL *This
>
> + )
>
> +{
>
> + // No Flush required for the NOR Flash driver
>
> + // because cache operations are not permitted.
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoFlushBlocks: Function NOT IMPLEMENTED (not required).\n"));
>
> +
>
> + // Nothing to do so just return without error
>
> + return EFI_SUCCESS;
>
> +}
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c
> new file mode 100644
> index 000000000000..f7b92de21a57
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashDxe.c
> @@ -0,0 +1,506 @@
> +/** @file NorFlashDxe.c
>
> +
>
> + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> +**/
>
> +
>
> +#include <Library/UefiLib.h>
>
> +#include <Library/BaseMemoryLib.h>
>
> +#include <Library/MemoryAllocationLib.h>
>
> +#include <Library/UefiBootServicesTableLib.h>
>
> +#include <Library/PcdLib.h>
>
> +#include <Library/HobLib.h>
>
> +#include <Library/DxeServicesTableLib.h>
>
> +
>
> +#include "NorFlash.h"
>
> +
>
> +STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;
>
> +
>
> +//
>
> +// Global variable declarations
>
> +//
>
> +NOR_FLASH_INSTANCE **mNorFlashInstances;
>
> +UINT32 mNorFlashDeviceCount;
>
> +UINTN mFlashNvStorageVariableBase;
>
> +EFI_EVENT mFvbVirtualAddrChangeEvent;
>
> +
>
> +NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {
>
> + NOR_FLASH_SIGNATURE, // Signature
>
> + NULL, // Handle ... NEED TO BE FILLED
>
> +
>
> + 0, // DeviceBaseAddress ... NEED TO BE FILLED
>
> + 0, // RegionBaseAddress ... NEED TO BE FILLED
>
> + 0, // Size ... NEED TO BE FILLED
>
> + 0, // StartLba
>
> +
>
> + {
>
> + EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision
>
> + NULL, // Media ... NEED TO BE FILLED
>
> + NorFlashBlockIoReset, // Reset;
>
> + NorFlashBlockIoReadBlocks, // ReadBlocks
>
> + NorFlashBlockIoWriteBlocks, // WriteBlocks
>
> + NorFlashBlockIoFlushBlocks // FlushBlocks
>
> + }, // BlockIoProtocol
>
> +
>
> + {
>
> + 0, // MediaId ... NEED TO BE FILLED
>
> + FALSE, // RemovableMedia
>
> + TRUE, // MediaPresent
>
> + FALSE, // LogicalPartition
>
> + FALSE, // ReadOnly
>
> + FALSE, // WriteCaching;
>
> + 0, // BlockSize ... NEED TO BE FILLED
>
> + 4, // IoAlign
>
> + 0, // LastBlock ... NEED TO BE FILLED
>
> + 0, // LowestAlignedLba
>
> + 1, // LogicalBlocksPerPhysicalBlock
>
> + }, // Media;
>
> +
>
> + {
>
> + EFI_DISK_IO_PROTOCOL_REVISION, // Revision
>
> + NorFlashDiskIoReadDisk, // ReadDisk
>
> + NorFlashDiskIoWriteDisk // WriteDisk
>
> + },
>
> +
>
> + {
>
> + 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
>
> +NorFlashCreateInstance (
>
> + IN UINTN NorFlashDeviceBase,
>
> + IN UINTN NorFlashRegionBase,
>
> + IN UINTN NorFlashSize,
>
> + IN UINT32 Index,
>
> + IN UINT32 BlockSize,
>
> + IN BOOLEAN SupportFvb,
>
> + OUT NOR_FLASH_INSTANCE **NorFlashInstance
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + ASSERT (NorFlashInstance != NULL);
>
> +
>
> + Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate);
>
> + if (Instance == NULL) {
>
> + return EFI_OUT_OF_RESOURCES;
>
> + }
>
> +
>
> + Instance->DeviceBaseAddress = NorFlashDeviceBase;
>
> + Instance->RegionBaseAddress = NorFlashRegionBase;
>
> + Instance->Size = NorFlashSize;
>
> +
>
> + Instance->BlockIoProtocol.Media = &Instance->Media;
>
> + Instance->Media.MediaId = Index;
>
> + Instance->Media.BlockSize = BlockSize;
>
> + Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;
>
> +
>
> + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);
>
> + Instance->DevicePath.Index = (UINT8)Index;
>
> +
>
> + Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);
>
> + if (Instance->ShadowBuffer == NULL) {
>
> + return EFI_OUT_OF_RESOURCES;
>
> + }
>
> +
>
> + if (SupportFvb) {
>
> + NorFlashFvbInitialize (Instance);
>
> +
>
> + Status = gBS->InstallMultipleProtocolInterfaces (
>
> + &Instance->Handle,
>
> + &gEfiDevicePathProtocolGuid,
>
> + &Instance->DevicePath,
>
> + &gEfiBlockIoProtocolGuid,
>
> + &Instance->BlockIoProtocol,
>
> + &gEfiFirmwareVolumeBlockProtocolGuid,
>
> + &Instance->FvbProtocol,
>
> + NULL
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + FreePool (Instance);
>
> + return Status;
>
> + }
>
> + } else {
>
> + Status = gBS->InstallMultipleProtocolInterfaces (
>
> + &Instance->Handle,
>
> + &gEfiDevicePathProtocolGuid,
>
> + &Instance->DevicePath,
>
> + &gEfiBlockIoProtocolGuid,
>
> + &Instance->BlockIoProtocol,
>
> + &gEfiDiskIoProtocolGuid,
>
> + &Instance->DiskIoProtocol,
>
> + NULL
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + FreePool (Instance);
>
> + return Status;
>
> + }
>
> + }
>
> +
>
> + *NorFlashInstance = Instance;
>
> + 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;
>
> + EFI_TPL OriginalTPL;
>
> +
>
> + if (!EfiAtRuntime ()) {
>
> + // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
>
> + OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
>
> + } else {
>
> + // This initialization is only to prevent the compiler to complain about the
>
> + // use of uninitialized variables
>
> + OriginalTPL = TPL_HIGH_LEVEL;
>
> + }
>
> +
>
> + Index = 0;
>
> + // The block erase might fail a first time (SW bug ?). Retry it ...
>
> + do {
>
> + // Unlock the block if we have to
>
> + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
>
> + if (EFI_ERROR (Status)) {
>
> + break;
>
> + }
>
> +
>
> + Status = NorFlashEraseSingleBlock (Instance, BlockAddress);
>
> + Index++;
>
> + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));
>
> +
>
> + if (Index == NOR_FLASH_ERASE_RETRY) {
>
> + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index));
>
> + }
>
> +
>
> + if (!EfiAtRuntime ()) {
>
> + // Interruptions can resume.
>
> + gBS->RestoreTPL (OriginalTPL);
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +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;
>
> + EFI_TPL OriginalTPL;
>
> + UINTN Cnt;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // Get the physical address of the block
>
> + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);
>
> +
>
> + // Start writing from the first address at the start of the block
>
> + WordAddress = BlockAddress;
>
> +
>
> + if (!EfiAtRuntime ()) {
>
> + // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
>
> + OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
>
> + } else {
>
> + // This initialization is only to prevent the compiler to complain about the
>
> + // use of uninitialized variables
>
> + OriginalTPL = TPL_HIGH_LEVEL;
>
> + }
>
> +
>
> + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));
>
> + goto EXIT;
>
> + }
>
> +
>
> + // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.
>
> +
>
> + // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero
>
> + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {
>
> + // First, break the entire block into buffer-sized chunks.
>
> + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;
>
> +
>
> + // Then feed each buffer chunk to the NOR Flash
>
> + // If a buffer does not contain any data, don't write it.
>
> + for (BufferIndex = 0;
>
> + BufferIndex < BuffersInBlock;
>
> + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS
>
> + )
>
> + {
>
> + // Check the buffer to see if it contains any data (not set all 1s).
>
> + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {
>
> + if (~DataBuffer[Cnt] != 0 ) {
>
> + // Some data found, write the buffer.
>
> + Status = NorFlashWriteBuffer (
>
> + Instance,
>
> + WordAddress,
>
> + P30_MAX_BUFFER_SIZE_IN_BYTES,
>
> + DataBuffer
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> +
>
> + break;
>
> + }
>
> + }
>
> + }
>
> +
>
> + // Finally, finish off any remaining words that are less than the maximum size of the buffer
>
> + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;
>
> +
>
> + if (RemainingWords != 0) {
>
> + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> + }
>
> + } else {
>
> + // For now, use the single word programming algorithm
>
> + // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,
>
> + // i.e. which ends in the range 0x......01 - 0x......7F.
>
> + for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {
>
> + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> + }
>
> + }
>
> +
>
> +EXIT:
>
> + if (!EfiAtRuntime ()) {
>
> + // Interruptions can resume.
>
> + gBS->RestoreTPL (OriginalTPL);
>
> + }
>
> +
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashInitialise (
>
> + IN EFI_HANDLE ImageHandle,
>
> + IN EFI_SYSTEM_TABLE *SystemTable
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 Index;
>
> + NOR_FLASH_DESCRIPTION *NorFlashDevices;
>
> + BOOLEAN ContainVariableStorage;
>
> +
>
> + Status = NorFlashPlatformInitialization ();
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
>
> + return Status;
>
> + }
>
> +
>
> + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n"));
>
> + return Status;
>
> + }
>
> +
>
> + mNorFlashInstances = AllocateRuntimePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount);
>
> +
>
> + for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
>
> + // Check if this NOR Flash device contain the variable storage region
>
> +
>
> + if (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) {
>
> + ContainVariableStorage =
>
> + (NorFlashDevices[Index].RegionBaseAddress <= PcdGet64 (PcdFlashNvStorageVariableBase64)) &&
>
> + (PcdGet64 (PcdFlashNvStorageVariableBase64) + PcdGet32 (PcdFlashNvStorageVariableSize) <=
>
> + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
>
> + } else {
>
> + ContainVariableStorage =
>
> + (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&
>
> + (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <=
>
> + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
>
> + }
>
> +
>
> + Status = NorFlashCreateInstance (
>
> + NorFlashDevices[Index].DeviceBaseAddress,
>
> + NorFlashDevices[Index].RegionBaseAddress,
>
> + NorFlashDevices[Index].Size,
>
> + Index,
>
> + NorFlashDevices[Index].BlockSize,
>
> + ContainVariableStorage,
>
> + &mNorFlashInstances[Index]
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index));
>
> + }
>
> + }
>
> +
>
> + //
>
> + // Register for the virtual address change event
>
> + //
>
> + Status = gBS->CreateEventEx (
>
> + EVT_NOTIFY_SIGNAL,
>
> + TPL_NOTIFY,
>
> + NorFlashVirtualNotifyEvent,
>
> + NULL,
>
> + &gEfiEventVirtualAddressChangeGuid,
>
> + &mNorFlashVirtualAddrChangeEvent
>
> + );
>
> + ASSERT_EFI_ERROR (Status);
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashFvbInitialize (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 FvbNumLba;
>
> + EFI_BOOT_MODE BootMode;
>
> + UINTN RuntimeMmioRegionSize;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "NorFlashFvbInitialize\n"));
>
> + ASSERT ((Instance != NULL));
>
> +
>
> + //
>
> + // Declare the Non-Volatile storage as EFI_MEMORY_RUNTIME
>
> + //
>
> +
>
> + // Note: all the NOR Flash region needs to be reserved into the UEFI Runtime memory;
>
> + // even if we only use the small block region at the top of the NOR Flash.
>
> + // The reason is when the NOR Flash memory is set into program mode, the command
>
> + // is written as the base of the flash region (ie: Instance->DeviceBaseAddress)
>
> + RuntimeMmioRegionSize = (Instance->RegionBaseAddress - Instance->DeviceBaseAddress) + Instance->Size;
>
> +
>
> + Status = gDS->AddMemorySpace (
>
> + EfiGcdMemoryTypeMemoryMappedIo,
>
> + Instance->DeviceBaseAddress,
>
> + RuntimeMmioRegionSize,
>
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
>
> + );
>
> + ASSERT_EFI_ERROR (Status);
>
> +
>
> + Status = gDS->SetMemorySpaceAttributes (
>
> + Instance->DeviceBaseAddress,
>
> + RuntimeMmioRegionSize,
>
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
>
> + );
>
> + ASSERT_EFI_ERROR (Status);
>
> +
>
> + mFlashNvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?
>
> + PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);
>
> +
>
> + // Set the index of the first LBA for the FVB
>
> + Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize;
>
> +
>
> + BootMode = GetBootModeHob ();
>
> + if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {
>
> + Status = EFI_INVALID_PARAMETER;
>
> + } else {
>
> + // Determine if there is a valid header at the beginning of the NorFlash
>
> + Status = ValidateFvHeader (Instance);
>
> + }
>
> +
>
> + // Install the Default FVB header if required
>
> + if (EFI_ERROR (Status)) {
>
> + // There is no valid header, so time to install one.
>
> + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: Installing a correct one for this volume.\n",
>
> + __FUNCTION__
>
> + ));
>
> +
>
> + // Erase all the NorFlash that is reserved for variable storage
>
> + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;
>
> +
>
> + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);
>
> + if (EFI_ERROR (Status)) {
>
> + return Status;
>
> + }
>
> +
>
> + // Install all appropriate headers
>
> + Status = InitializeFvAndVariableStoreHeaders (Instance);
>
> + if (EFI_ERROR (Status)) {
>
> + return Status;
>
> + }
>
> + }
>
> +
>
> + //
>
> + // The driver implementing the variable read service can now be dispatched;
>
> + // the varstore headers are in place.
>
> + //
>
> + Status = gBS->InstallProtocolInterface (
>
> + &gImageHandle,
>
> + &gEdkiiNvVarStoreFormattedGuid,
>
> + EFI_NATIVE_INTERFACE,
>
> + NULL
>
> + );
>
> + ASSERT_EFI_ERROR (Status);
>
> +
>
> + //
>
> + // Register for the virtual address change event
>
> + //
>
> + Status = gBS->CreateEventEx (
>
> + EVT_NOTIFY_SIGNAL,
>
> + TPL_NOTIFY,
>
> + FvbVirtualNotifyEvent,
>
> + NULL,
>
> + &gEfiEventVirtualAddressChangeGuid,
>
> + &mFvbVirtualAddrChangeEvent
>
> + );
>
> + ASSERT_EFI_ERROR (Status);
>
> +
>
> + return Status;
>
> +}
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c
> new file mode 100644
> index 000000000000..0767581308d2
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashFvb.c
> @@ -0,0 +1,777 @@
> +/*++ @file NorFlashFvbDxe.c
>
> +
>
> + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> + --*/
>
> +
>
> +#include <PiDxe.h>
>
> +
>
> +#include <Library/PcdLib.h>
>
> +#include <Library/BaseLib.h>
>
> +#include <Library/UefiLib.h>
>
> +#include <Library/BaseMemoryLib.h>
>
> +#include <Library/MemoryAllocationLib.h>
>
> +
>
> +#include <Guid/VariableFormat.h>
>
> +#include <Guid/SystemNvDataGuid.h>
>
> +#include <Guid/NvVarStoreFormatted.h>
>
> +
>
> +#include "NorFlash.h"
>
> +
>
> +extern 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;
>
> + UINT32 NvStorageFtwSpareSize;
>
> + UINT32 NvStorageFtwWorkingSize;
>
> + UINT32 NvStorageVariableSize;
>
> + UINT64 NvStorageFtwSpareBase;
>
> + UINT64 NvStorageFtwWorkingBase;
>
> + UINT64 NvStorageVariableBase;
>
> +
>
> + HeadersLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY) + sizeof (VARIABLE_STORE_HEADER);
>
> + Headers = AllocateZeroPool (HeadersLength);
>
> +
>
> + NvStorageFtwWorkingSize = PcdGet32 (PcdFlashNvStorageFtwWorkingSize);
>
> + NvStorageFtwSpareSize = PcdGet32 (PcdFlashNvStorageFtwSpareSize);
>
> + NvStorageVariableSize = PcdGet32 (PcdFlashNvStorageVariableSize);
>
> +
>
> + NvStorageFtwSpareBase = (PcdGet64 (PcdFlashNvStorageFtwSpareBase64) != 0) ?
>
> + PcdGet64 (PcdFlashNvStorageFtwSpareBase64) : PcdGet32 (PcdFlashNvStorageFtwSpareBase);
>
> + NvStorageFtwWorkingBase = (PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) != 0) ?
>
> + PcdGet64 (PcdFlashNvStorageFtwWorkingBase64) : PcdGet32 (PcdFlashNvStorageFtwWorkingBase);
>
> + NvStorageVariableBase = (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?
>
> + PcdGet64 (PcdFlashNvStorageVariableBase64) : PcdGet32 (PcdFlashNvStorageVariableBase);
>
> +
>
> + // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.
>
> + if ((NvStorageVariableBase + NvStorageVariableSize) != NvStorageFtwWorkingBase) {
>
> + DEBUG ((
>
> + DEBUG_ERROR,
>
> + "%a: NvStorageFtwWorkingBase is not contiguous with NvStorageVariableBase region\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + if ((NvStorageFtwWorkingBase + NvStorageFtwWorkingSize) != NvStorageFtwSpareBase) {
>
> + DEBUG ((
>
> + DEBUG_ERROR,
>
> + "%a: NvStorageFtwSpareBase is not contiguous with NvStorageFtwWorkingBase region\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Check if the size of the area is at least one block size
>
> + if ((NvStorageVariableSize <= 0) || (NvStorageVariableSize / Instance->Media.BlockSize <= 0)) {
>
> + DEBUG ((
>
> + DEBUG_ERROR,
>
> + "%a: NvStorageVariableSize is 0x%x, should be atleast one block size\n",
>
> + __FUNCTION__,
>
> + NvStorageVariableSize
>
> + ));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + if ((NvStorageFtwWorkingSize <= 0) || (NvStorageFtwWorkingSize / Instance->Media.BlockSize <= 0)) {
>
> + DEBUG ((
>
> + DEBUG_ERROR,
>
> + "%a: NvStorageFtwWorkingSize is 0x%x, should be atleast one block size\n",
>
> + __FUNCTION__,
>
> + NvStorageFtwWorkingSize
>
> + ));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + if ((NvStorageFtwSpareSize <= 0) || (NvStorageFtwSpareSize / Instance->Media.BlockSize <= 0)) {
>
> + DEBUG ((
>
> + DEBUG_ERROR,
>
> + "%a: NvStorageFtwSpareSize is 0x%x, should be atleast one block size\n",
>
> + __FUNCTION__,
>
> + NvStorageFtwSpareSize
>
> + ));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + // Ensure the Variable area Base Addresses are aligned on a block size boundaries
>
> + if ((NvStorageVariableBase % Instance->Media.BlockSize != 0) ||
>
> + (NvStorageFtwWorkingBase % Instance->Media.BlockSize != 0) ||
>
> + (NvStorageFtwSpareBase % Instance->Media.BlockSize != 0))
>
> + {
>
> + DEBUG ((DEBUG_ERROR, "%a: NvStorage Base addresses must be aligned to block size boundaries", __FUNCTION__));
>
> + return EFI_INVALID_PARAMETER;
>
> + }
>
> +
>
> + //
>
> + // EFI_FIRMWARE_VOLUME_HEADER
>
> + //
>
> + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Headers;
>
> + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
>
> + FirmwareVolumeHeader->FvLength =
>
> + PcdGet32 (PcdFlashNvStorageVariableSize) +
>
> + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
>
> + PcdGet32 (PcdFlashNvStorageFtwSpareSize);
>
> + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;
>
> + FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2)(
>
> + EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled
>
> + EFI_FVB2_READ_STATUS | // Reads are currently enabled
>
> + EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
>
> + EFI_FVB2_MEMORY_MAPPED | // It is memory mapped
>
> + EFI_FVB2_ERASE_POLARITY | // After erasure all bits take this value (i.e. '1')
>
> + EFI_FVB2_WRITE_STATUS | // Writes are currently enabled
>
> + EFI_FVB2_WRITE_ENABLED_CAP // Writes may be enabled
>
> + );
>
> + FirmwareVolumeHeader->HeaderLength = sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY);
>
> + FirmwareVolumeHeader->Revision = EFI_FVH_REVISION;
>
> + FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->Media.LastBlock + 1;
>
> + FirmwareVolumeHeader->BlockMap[0].Length = Instance->Media.BlockSize;
>
> + FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;
>
> + FirmwareVolumeHeader->BlockMap[1].Length = 0;
>
> + FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ((UINT16 *)FirmwareVolumeHeader, FirmwareVolumeHeader->HeaderLength);
>
> +
>
> + //
>
> + // VARIABLE_STORE_HEADER
>
> + //
>
> + VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)Headers + FirmwareVolumeHeader->HeaderLength);
>
> + CopyGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid);
>
> + VariableStoreHeader->Size = PcdGet32 (PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength;
>
> + VariableStoreHeader->Format = VARIABLE_STORE_FORMATTED;
>
> + VariableStoreHeader->State = VARIABLE_STORE_HEALTHY;
>
> +
>
> + // Install the combined super-header in the NorFlash
>
> + Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);
>
> +
>
> + FreePool (Headers);
>
> + return Status;
>
> +}
>
> +
>
> +/**
>
> + Check the integrity of firmware volume header.
>
> +
>
> + @param[in] FwVolHeader - A pointer to a firmware volume header
>
> +
>
> + @retval EFI_SUCCESS - The firmware volume is consistent
>
> + @retval EFI_NOT_FOUND - The firmware volume has been corrupted.
>
> +
>
> +**/
>
> +EFI_STATUS
>
> +ValidateFvHeader (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + )
>
> +{
>
> + UINT16 Checksum;
>
> + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
>
> + VARIABLE_STORE_HEADER *VariableStoreHeader;
>
> + UINTN VariableStoreLength;
>
> + UINTN FvLength;
>
> +
>
> + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Instance->RegionBaseAddress;
>
> +
>
> + FvLength = PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
>
> + PcdGet32 (PcdFlashNvStorageFtwSpareSize);
>
> +
>
> + //
>
> + // Verify the header revision, header signature, length
>
> + // Length of FvBlock cannot be 2**64-1
>
> + // HeaderLength cannot be an odd number
>
> + //
>
> + if ( (FwVolHeader->Revision != EFI_FVH_REVISION)
>
> + || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)
>
> + || (FwVolHeader->FvLength != FvLength)
>
> + )
>
> + {
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: No Firmware Volume header present\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_NOT_FOUND;
>
> + }
>
> +
>
> + // Check the Firmware Volume Guid
>
> + if ( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: Firmware Volume Guid non-compatible\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_NOT_FOUND;
>
> + }
>
> +
>
> + // Verify the header checksum
>
> + Checksum = CalculateSum16 ((UINT16 *)FwVolHeader, FwVolHeader->HeaderLength);
>
> + if (Checksum != 0) {
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: FV checksum is invalid (Checksum:0x%X)\n",
>
> + __FUNCTION__,
>
> + Checksum
>
> + ));
>
> + return EFI_NOT_FOUND;
>
> + }
>
> +
>
> + VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)FwVolHeader + FwVolHeader->HeaderLength);
>
> +
>
> + // Check the Variable Store Guid
>
> + if (!CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) &&
>
> + !CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid))
>
> + {
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: Variable Store Guid non-compatible\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_NOT_FOUND;
>
> + }
>
> +
>
> + VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;
>
> + if (VariableStoreHeader->Size != VariableStoreLength) {
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: Variable Store Length does not match\n",
>
> + __FUNCTION__
>
> + ));
>
> + return EFI_NOT_FOUND;
>
> + }
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/**
>
> + The GetAttributes() function retrieves the attributes and
>
> + current settings of the block.
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and
>
> + current settings are returned.
>
> + Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.
>
> +
>
> + @retval EFI_SUCCESS The firmware volume attributes were returned.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetAttributes (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + OUT EFI_FVB_ATTRIBUTES_2 *Attributes
>
> + )
>
> +{
>
> + EFI_FVB_ATTRIBUTES_2 FlashFvbAttributes;
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2)(
>
> +
>
> + EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled
>
> + EFI_FVB2_READ_STATUS | // Reads are currently enabled
>
> + EFI_FVB2_STICKY_WRITE | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
>
> + EFI_FVB2_MEMORY_MAPPED | // It is memory mapped
>
> + EFI_FVB2_ERASE_POLARITY // After erasure all bits take this value (i.e. '1')
>
> +
>
> + );
>
> +
>
> + // Check if it is write protected
>
> + if (Instance->Media.ReadOnly != TRUE) {
>
> + FlashFvbAttributes = FlashFvbAttributes |
>
> + EFI_FVB2_WRITE_STATUS | // Writes are currently enabled
>
> + EFI_FVB2_WRITE_ENABLED_CAP; // Writes may be enabled
>
> + }
>
> +
>
> + *Attributes = FlashFvbAttributes;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/**
>
> + The SetAttributes() function sets configurable firmware volume attributes
>
> + and returns the new settings of the firmware volume.
>
> +
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Attributes On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2
>
> + that contains the desired firmware volume settings.
>
> + On successful return, it contains the new settings of
>
> + the firmware volume.
>
> + Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.
>
> +
>
> + @retval EFI_SUCCESS The firmware volume attributes were returned.
>
> +
>
> + @retval EFI_INVALID_PARAMETER The attributes requested are in conflict with the capabilities
>
> + as declared in the firmware volume header.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbSetAttributes (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
>
> + )
>
> +{
>
> + DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n", *Attributes));
>
> + return EFI_UNSUPPORTED;
>
> +}
>
> +
>
> +/**
>
> + The GetPhysicalAddress() function retrieves the base address of
>
> + a memory-mapped firmware volume. This function should be called
>
> + only for memory-mapped firmware volumes.
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Address Pointer to a caller-allocated
>
> + EFI_PHYSICAL_ADDRESS that, on successful
>
> + return from GetPhysicalAddress(), contains the
>
> + base address of the firmware volume.
>
> +
>
> + @retval EFI_SUCCESS The firmware volume base address was returned.
>
> +
>
> + @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetPhysicalAddress (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + OUT EFI_PHYSICAL_ADDRESS *Address
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress));
>
> +
>
> + ASSERT (Address != NULL);
>
> +
>
> + *Address = mFlashNvStorageVariableBase;
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/**
>
> + The GetBlockSize() function retrieves the size of the requested
>
> + block. It also returns the number of additional blocks with
>
> + the identical size. The GetBlockSize() function is used to
>
> + retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
>
> +
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Lba Indicates the block for which to return the size.
>
> +
>
> + @param BlockSize Pointer to a caller-allocated UINTN in which
>
> + the size of the block is returned.
>
> +
>
> + @param NumberOfBlocks Pointer to a caller-allocated UINTN in
>
> + which the number of consecutive blocks,
>
> + starting with Lba, is returned. All
>
> + blocks in this range have a size of
>
> + BlockSize.
>
> +
>
> +
>
> + @retval EFI_SUCCESS The firmware volume base address was returned.
>
> +
>
> + @retval EFI_INVALID_PARAMETER The requested LBA is out of range.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbGetBlockSize (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + OUT UINTN *BlockSize,
>
> + OUT UINTN *NumberOfBlocks
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->Media.BlockSize, Instance->Media.LastBlock));
>
> +
>
> + if (Lba > Instance->Media.LastBlock) {
>
> + DEBUG ((DEBUG_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->Media.LastBlock));
>
> + Status = EFI_INVALID_PARAMETER;
>
> + } else {
>
> + // This is easy because in this platform each NorFlash device has equal sized blocks.
>
> + *BlockSize = (UINTN)Instance->Media.BlockSize;
>
> + *NumberOfBlocks = (UINTN)(Instance->Media.LastBlock - Lba + 1);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks));
>
> +
>
> + Status = EFI_SUCCESS;
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +/**
>
> + Reads the specified number of bytes into a buffer from the specified block.
>
> +
>
> + The Read() function reads the requested number of bytes from the
>
> + requested block and stores them in the provided buffer.
>
> + Implementations should be mindful that the firmware volume
>
> + might be in the ReadDisabled state. If it is in this state,
>
> + the Read() function must return the status code
>
> + EFI_ACCESS_DENIED without modifying the contents of the
>
> + buffer. The Read() function must also prevent spanning block
>
> + boundaries. If a read is requested that would span a block
>
> + boundary, the read must read up to the boundary but not
>
> + beyond. The output parameter NumBytes must be set to correctly
>
> + indicate the number of bytes actually read. The caller must be
>
> + aware that a read may be partially completed.
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Lba The starting logical block index from which to read.
>
> +
>
> + @param Offset Offset into the block at which to begin reading.
>
> +
>
> + @param NumBytes Pointer to a UINTN.
>
> + At entry, *NumBytes contains the total size of the buffer.
>
> + At exit, *NumBytes contains the total number of bytes read.
>
> +
>
> + @param Buffer Pointer to a caller-allocated buffer that will be used
>
> + to hold the data that is read.
>
> +
>
> + @retval EFI_SUCCESS The firmware volume was read successfully, and contents are
>
> + in Buffer.
>
> +
>
> + @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary.
>
> + On output, NumBytes contains the total number of bytes
>
> + returned in Buffer.
>
> +
>
> + @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state.
>
> +
>
> + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be read.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbRead (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN OUT UINTN *NumBytes,
>
> + IN OUT UINT8 *Buffer
>
> + )
>
> +{
>
> + EFI_STATUS TempStatus;
>
> + UINTN BlockSize;
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));
>
> +
>
> + TempStatus = EFI_SUCCESS;
>
> +
>
> + // Cache the block size to avoid de-referencing pointers all the time
>
> + BlockSize = Instance->Media.BlockSize;
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
>
> +
>
> + // The read must not span block boundaries.
>
> + // We need to check each variable individually because adding two large values together overflows.
>
> + if ((Offset >= BlockSize) ||
>
> + (*NumBytes > BlockSize) ||
>
> + ((Offset + *NumBytes) > BlockSize))
>
> + {
>
> + DEBUG ((DEBUG_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize));
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // We must have some bytes to read
>
> + if (*NumBytes == 0) {
>
> + return EFI_BAD_BUFFER_SIZE;
>
> + }
>
> +
>
> + // Decide if we are doing full block reads or not.
>
> + if (*NumBytes % BlockSize != 0) {
>
> + TempStatus = NorFlashRead (Instance, Instance->StartLba + Lba, Offset, *NumBytes, Buffer);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> + } else {
>
> + // Read NOR Flash data into shadow buffer
>
> + TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, Buffer);
>
> + if (EFI_ERROR (TempStatus)) {
>
> + // Return one of the pre-approved error statuses
>
> + return EFI_DEVICE_ERROR;
>
> + }
>
> + }
>
> +
>
> + return EFI_SUCCESS;
>
> +}
>
> +
>
> +/**
>
> + Writes the specified number of bytes from the input buffer to the block.
>
> +
>
> + The Write() function writes the specified number of bytes from
>
> + the provided buffer to the specified block and offset. If the
>
> + firmware volume is sticky write, the caller must ensure that
>
> + all the bits of the specified range to write are in the
>
> + EFI_FVB_ERASE_POLARITY state before calling the Write()
>
> + function, or else the result will be unpredictable. This
>
> + unpredictability arises because, for a sticky-write firmware
>
> + volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY
>
> + state but cannot flip it back again. Before calling the
>
> + Write() function, it is recommended for the caller to first call
>
> + the EraseBlocks() function to erase the specified block to
>
> + write. A block erase cycle will transition bits from the
>
> + (NOT)EFI_FVB_ERASE_POLARITY state back to the
>
> + EFI_FVB_ERASE_POLARITY state. Implementations should be
>
> + mindful that the firmware volume might be in the WriteDisabled
>
> + state. If it is in this state, the Write() function must
>
> + return the status code EFI_ACCESS_DENIED without modifying the
>
> + contents of the firmware volume. The Write() function must
>
> + also prevent spanning block boundaries. If a write is
>
> + requested that spans a block boundary, the write must store up
>
> + to the boundary but not beyond. The output parameter NumBytes
>
> + must be set to correctly indicate the number of bytes actually
>
> + written. The caller must be aware that a write may be
>
> + partially completed. All writes, partial or otherwise, must be
>
> + fully flushed to the hardware before the Write() service
>
> + returns.
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
>
> +
>
> + @param Lba The starting logical block index to write to.
>
> +
>
> + @param Offset Offset into the block at which to begin writing.
>
> +
>
> + @param NumBytes The pointer to a UINTN.
>
> + At entry, *NumBytes contains the total size of the buffer.
>
> + At exit, *NumBytes contains the total number of bytes actually written.
>
> +
>
> + @param Buffer The pointer to a caller-allocated buffer that contains the source for the write.
>
> +
>
> + @retval EFI_SUCCESS The firmware volume was written successfully.
>
> +
>
> + @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary.
>
> + On output, NumBytes contains the total number of bytes
>
> + actually written.
>
> +
>
> + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.
>
> +
>
> + @retval EFI_DEVICE_ERROR The block device is malfunctioning and could not be written.
>
> +
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbWrite (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + IN EFI_LBA Lba,
>
> + IN UINTN Offset,
>
> + IN OUT UINTN *NumBytes,
>
> + IN UINT8 *Buffer
>
> + )
>
> +{
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + return NorFlashWriteSingleBlock (Instance, Instance->StartLba + Lba, Offset, NumBytes, Buffer);
>
> +}
>
> +
>
> +/**
>
> + Erases and initialises a firmware volume block.
>
> +
>
> + The EraseBlocks() function erases one or more blocks as denoted
>
> + by the variable argument list. The entire parameter list of
>
> + blocks must be verified before erasing any blocks. If a block is
>
> + requested that does not exist within the associated firmware
>
> + volume (it has a larger index than the last block of the
>
> + firmware volume), the EraseBlocks() function must return the
>
> + status code EFI_INVALID_PARAMETER without modifying the contents
>
> + of the firmware volume. Implementations should be mindful that
>
> + the firmware volume might be in the WriteDisabled state. If it
>
> + is in this state, the EraseBlocks() function must return the
>
> + status code EFI_ACCESS_DENIED without modifying the contents of
>
> + the firmware volume. All calls to EraseBlocks() must be fully
>
> + flushed to the hardware before the EraseBlocks() service
>
> + returns.
>
> +
>
> + @param This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
>
> + instance.
>
> +
>
> + @param ... The variable argument list is a list of tuples.
>
> + Each tuple describes a range of LBAs to erase
>
> + and consists of the following:
>
> + - An EFI_LBA that indicates the starting LBA
>
> + - A UINTN that indicates the number of blocks to erase.
>
> +
>
> + The list is terminated with an EFI_LBA_LIST_TERMINATOR.
>
> + For example, the following indicates that two ranges of blocks
>
> + (5-7 and 10-11) are to be erased:
>
> + EraseBlocks (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);
>
> +
>
> + @retval EFI_SUCCESS The erase request successfully completed.
>
> +
>
> + @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state.
>
> +
>
> + @retval EFI_DEVICE_ERROR The block device is not functioning correctly and could not be written.
>
> + The firmware device may have been partially erased.
>
> +
>
> + @retval EFI_INVALID_PARAMETER One or more of the LBAs listed in the variable argument list do
>
> + not exist in the firmware volume.
>
> +
>
> + **/
>
> +EFI_STATUS
>
> +EFIAPI
>
> +FvbEraseBlocks (
>
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
>
> + ...
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + VA_LIST Args;
>
> + UINTN BlockAddress; // Physical address of Lba to erase
>
> + EFI_LBA StartingLba; // Lba from which we start erasing
>
> + UINTN NumOfLba; // Number of Lba blocks to erase
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + Instance = INSTANCE_FROM_FVB_THIS (This);
>
> +
>
> + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // Detect WriteDisabled state
>
> + if (Instance->Media.ReadOnly == TRUE) {
>
> + // Firmware volume is in WriteDisabled state
>
> + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Device is in WriteDisabled state.\n"));
>
> + return EFI_ACCESS_DENIED;
>
> + }
>
> +
>
> + // Before erasing, check the entire list of parameters to ensure all specified blocks are valid
>
> +
>
> + VA_START (Args, This);
>
> + do {
>
> + // Get the Lba from which we start erasing
>
> + StartingLba = VA_ARG (Args, EFI_LBA);
>
> +
>
> + // Have we reached the end of the list?
>
> + if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
>
> + // Exit the while loop
>
> + break;
>
> + }
>
> +
>
> + // How many Lba blocks are we requested to erase?
>
> + NumOfLba = VA_ARG (Args, UINTN);
>
> +
>
> + // All blocks must be within range
>
> + DEBUG ((
>
> + DEBUG_BLKIO,
>
> + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%Lu - 1 ) > LastBlock=%ld.\n",
>
> + Instance->StartLba + StartingLba,
>
> + (UINT64)NumOfLba,
>
> + Instance->Media.LastBlock
>
> + ));
>
> + if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->Media.LastBlock)) {
>
> + VA_END (Args);
>
> + DEBUG ((DEBUG_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));
>
> + Status = EFI_INVALID_PARAMETER;
>
> + goto EXIT;
>
> + }
>
> + } while (TRUE);
>
> +
>
> + VA_END (Args);
>
> +
>
> + //
>
> + // To get here, all must be ok, so start erasing
>
> + //
>
> + VA_START (Args, This);
>
> + do {
>
> + // Get the Lba from which we start erasing
>
> + StartingLba = VA_ARG (Args, EFI_LBA);
>
> +
>
> + // Have we reached the end of the list?
>
> + if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
>
> + // Exit the while loop
>
> + break;
>
> + }
>
> +
>
> + // How many Lba blocks are we requested to erase?
>
> + NumOfLba = VA_ARG (Args, UINTN);
>
> +
>
> + // Go through each one and erase it
>
> + while (NumOfLba > 0) {
>
> + // Get the physical address of Lba to erase
>
> + BlockAddress = GET_NOR_BLOCK_ADDRESS (
>
> + Instance->RegionBaseAddress,
>
> + Instance->StartLba + StartingLba,
>
> + Instance->Media.BlockSize
>
> + );
>
> +
>
> + // Erase it
>
> + DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress));
>
> + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
>
> + if (EFI_ERROR (Status)) {
>
> + VA_END (Args);
>
> + Status = EFI_DEVICE_ERROR;
>
> + goto EXIT;
>
> + }
>
> +
>
> + // Move to the next Lba
>
> + StartingLba++;
>
> + NumOfLba--;
>
> + }
>
> + } while (TRUE);
>
> +
>
> + VA_END (Args);
>
> +
>
> +EXIT:
>
> + return Status;
>
> +}
>
> +
>
> +/**
>
> + Fixup internal data so that EFI can be call in virtual mode.
>
> + Call the passed in Child Notify event and convert any pointers in
>
> + lib to virtual mode.
>
> +
>
> + @param[in] Event The Event that is being processed
>
> + @param[in] Context Event Context
>
> +**/
>
> +VOID
>
> +EFIAPI
>
> +FvbVirtualNotifyEvent (
>
> + IN EFI_EVENT Event,
>
> + IN VOID *Context
>
> + )
>
> +{
>
> + EfiConvertPointer (0x0, (VOID **)&mFlashNvStorageVariableBase);
>
> + return;
>
> +}
>
> diff --git a/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c
> new file mode 100644
> index 000000000000..b72ad97b0b55
> --- /dev/null
> +++ b/Platform/ARM/Drivers/NorFlashDxe/NorFlashStandaloneMm.c
> @@ -0,0 +1,383 @@
> +/** @file NorFlashStandaloneMm.c
>
> +
>
> + Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
>
> + Copyright (c) 2020, Linaro, Ltd. All rights reserved.<BR>
>
> +
>
> + SPDX-License-Identifier: BSD-2-Clause-Patent
>
> +
>
> +**/
>
> +
>
> +#include <Library/BaseMemoryLib.h>
>
> +#include <Library/MemoryAllocationLib.h>
>
> +#include <Library/MmServicesTableLib.h>
>
> +
>
> +#include "NorFlash.h"
>
> +
>
> +//
>
> +// Global variable declarations
>
> +//
>
> +NOR_FLASH_INSTANCE **mNorFlashInstances;
>
> +UINT32 mNorFlashDeviceCount;
>
> +UINTN mFlashNvStorageVariableBase;
>
> +
>
> +NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {
>
> + NOR_FLASH_SIGNATURE, // Signature
>
> + NULL, // Handle ... NEED TO BE FILLED
>
> +
>
> + 0, // DeviceBaseAddress ... NEED TO BE FILLED
>
> + 0, // RegionBaseAddress ... NEED TO BE FILLED
>
> + 0, // Size ... NEED TO BE FILLED
>
> + 0, // StartLba
>
> +
>
> + {
>
> + EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision
>
> + NULL, // Media ... NEED TO BE FILLED
>
> + NULL, // Reset;
>
> + NULL, // ReadBlocks
>
> + NULL, // WriteBlocks
>
> + NULL // FlushBlocks
>
> + }, // BlockIoProtocol
>
> +
>
> + {
>
> + 0, // MediaId ... NEED TO BE FILLED
>
> + FALSE, // RemovableMedia
>
> + TRUE, // MediaPresent
>
> + FALSE, // LogicalPartition
>
> + FALSE, // ReadOnly
>
> + FALSE, // WriteCaching;
>
> + 0, // BlockSize ... NEED TO BE FILLED
>
> + 4, // IoAlign
>
> + 0, // LastBlock ... NEED TO BE FILLED
>
> + 0, // LowestAlignedLba
>
> + 1, // LogicalBlocksPerPhysicalBlock
>
> + }, // Media;
>
> +
>
> + {
>
> + EFI_DISK_IO_PROTOCOL_REVISION, // Revision
>
> + NULL, // ReadDisk
>
> + NULL // WriteDisk
>
> + },
>
> +
>
> + {
>
> + 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
>
> +NorFlashCreateInstance (
>
> + IN UINTN NorFlashDeviceBase,
>
> + IN UINTN NorFlashRegionBase,
>
> + IN UINTN NorFlashSize,
>
> + IN UINT32 Index,
>
> + IN UINT32 BlockSize,
>
> + IN BOOLEAN SupportFvb,
>
> + OUT NOR_FLASH_INSTANCE **NorFlashInstance
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + NOR_FLASH_INSTANCE *Instance;
>
> +
>
> + ASSERT (NorFlashInstance != NULL);
>
> +
>
> + Instance = AllocateRuntimeCopyPool (sizeof (NOR_FLASH_INSTANCE), &mNorFlashInstanceTemplate);
>
> + if (Instance == NULL) {
>
> + return EFI_OUT_OF_RESOURCES;
>
> + }
>
> +
>
> + Instance->DeviceBaseAddress = NorFlashDeviceBase;
>
> + Instance->RegionBaseAddress = NorFlashRegionBase;
>
> + Instance->Size = NorFlashSize;
>
> +
>
> + Instance->BlockIoProtocol.Media = &Instance->Media;
>
> + Instance->Media.MediaId = Index;
>
> + Instance->Media.BlockSize = BlockSize;
>
> + Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;
>
> +
>
> + CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);
>
> + Instance->DevicePath.Index = (UINT8)Index;
>
> +
>
> + Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);
>
> + if (Instance->ShadowBuffer == NULL) {
>
> + return EFI_OUT_OF_RESOURCES;
>
> + }
>
> +
>
> + if (SupportFvb) {
>
> + NorFlashFvbInitialize (Instance);
>
> +
>
> + Status = gMmst->MmInstallProtocolInterface (
>
> + &Instance->Handle,
>
> + &gEfiSmmFirmwareVolumeBlockProtocolGuid,
>
> + EFI_NATIVE_INTERFACE,
>
> + &Instance->FvbProtocol
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + FreePool (Instance);
>
> + return Status;
>
> + }
>
> + } else {
>
> + DEBUG ((DEBUG_ERROR, "standalone MM NOR Flash driver only support FVB.\n"));
>
> + FreePool (Instance);
>
> + return EFI_UNSUPPORTED;
>
> + }
>
> +
>
> + *NorFlashInstance = Instance;
>
> + 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;
>
> +
>
> + Index = 0;
>
> + // The block erase might fail a first time (SW bug ?). Retry it ...
>
> + do {
>
> + // Unlock the block if we have to
>
> + Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
>
> + if (EFI_ERROR (Status)) {
>
> + break;
>
> + }
>
> +
>
> + Status = NorFlashEraseSingleBlock (Instance, BlockAddress);
>
> + Index++;
>
> + } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));
>
> +
>
> + if (Index == NOR_FLASH_ERASE_RETRY) {
>
> + DEBUG ((DEBUG_ERROR, "EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress, Index));
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +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;
>
> +
>
> + Status = EFI_SUCCESS;
>
> +
>
> + // Get the physical address of the block
>
> + BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);
>
> +
>
> + // Start writing from the first address at the start of the block
>
> + WordAddress = BlockAddress;
>
> +
>
> + Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));
>
> + goto EXIT;
>
> + }
>
> +
>
> + // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.
>
> +
>
> + // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero
>
> + if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {
>
> + // First, break the entire block into buffer-sized chunks.
>
> + BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;
>
> +
>
> + // Then feed each buffer chunk to the NOR Flash
>
> + // If a buffer does not contain any data, don't write it.
>
> + for (BufferIndex = 0;
>
> + BufferIndex < BuffersInBlock;
>
> + BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS
>
> + )
>
> + {
>
> + // Check the buffer to see if it contains any data (not set all 1s).
>
> + for (Cnt = 0; Cnt < P30_MAX_BUFFER_SIZE_IN_WORDS; Cnt++) {
>
> + if (~DataBuffer[Cnt] != 0 ) {
>
> + // Some data found, write the buffer.
>
> + Status = NorFlashWriteBuffer (
>
> + Instance,
>
> + WordAddress,
>
> + P30_MAX_BUFFER_SIZE_IN_BYTES,
>
> + DataBuffer
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> +
>
> + break;
>
> + }
>
> + }
>
> + }
>
> +
>
> + // Finally, finish off any remaining words that are less than the maximum size of the buffer
>
> + RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;
>
> +
>
> + if (RemainingWords != 0) {
>
> + Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> + }
>
> + } else {
>
> + // For now, use the single word programming algorithm
>
> + // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,
>
> + // i.e. which ends in the range 0x......01 - 0x......7F.
>
> + for (WordIndex = 0; WordIndex < BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {
>
> + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
>
> + if (EFI_ERROR (Status)) {
>
> + goto EXIT;
>
> + }
>
> + }
>
> + }
>
> +
>
> +EXIT:
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashInitialise (
>
> + IN EFI_HANDLE ImageHandle,
>
> + IN EFI_MM_SYSTEM_TABLE *MmSystemTable
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 Index;
>
> + NOR_FLASH_DESCRIPTION *NorFlashDevices;
>
> + BOOLEAN ContainVariableStorage;
>
> +
>
> + Status = NorFlashPlatformInitialization ();
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
>
> + return Status;
>
> + }
>
> +
>
> + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to get Nor Flash devices\n"));
>
> + return Status;
>
> + }
>
> +
>
> + mNorFlashInstances = AllocatePool (sizeof (NOR_FLASH_INSTANCE *) * mNorFlashDeviceCount);
>
> +
>
> + for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
>
> + // Check if this NOR Flash device contain the variable storage region
>
> +
>
> + if (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) {
>
> + ContainVariableStorage =
>
> + (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet64 (PcdFlashNvStorageVariableBase64)) &&
>
> + (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <=
>
> + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
>
> + } else {
>
> + ContainVariableStorage =
>
> + (NorFlashDevices[Index].RegionBaseAddress <= FixedPcdGet32 (PcdFlashNvStorageVariableBase)) &&
>
> + (FixedPcdGet32 (PcdFlashNvStorageVariableBase) + FixedPcdGet32 (PcdFlashNvStorageVariableSize) <=
>
> + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
>
> + }
>
> +
>
> + Status = NorFlashCreateInstance (
>
> + NorFlashDevices[Index].DeviceBaseAddress,
>
> + NorFlashDevices[Index].RegionBaseAddress,
>
> + NorFlashDevices[Index].Size,
>
> + Index,
>
> + NorFlashDevices[Index].BlockSize,
>
> + ContainVariableStorage,
>
> + &mNorFlashInstances[Index]
>
> + );
>
> + if (EFI_ERROR (Status)) {
>
> + DEBUG ((DEBUG_ERROR, "NorFlashInitialise: Fail to create instance for NorFlash[%d]\n", Index));
>
> + }
>
> + }
>
> +
>
> + return Status;
>
> +}
>
> +
>
> +EFI_STATUS
>
> +EFIAPI
>
> +NorFlashFvbInitialize (
>
> + IN NOR_FLASH_INSTANCE *Instance
>
> + )
>
> +{
>
> + EFI_STATUS Status;
>
> + UINT32 FvbNumLba;
>
> +
>
> + ASSERT ((Instance != NULL));
>
> +
>
> + mFlashNvStorageVariableBase = (FixedPcdGet64 (PcdFlashNvStorageVariableBase64) != 0) ?
>
> + FixedPcdGet64 (PcdFlashNvStorageVariableBase64) : FixedPcdGet32 (PcdFlashNvStorageVariableBase);
>
> + // Set the index of the first LBA for the FVB
>
> + Instance->StartLba = (mFlashNvStorageVariableBase - Instance->RegionBaseAddress) / Instance->Media.BlockSize;
>
> +
>
> + // Determine if there is a valid header at the beginning of the NorFlash
>
> + Status = ValidateFvHeader (Instance);
>
> +
>
> + // Install the Default FVB header if required
>
> + if (EFI_ERROR (Status)) {
>
> + // There is no valid header, so time to install one.
>
> + DEBUG ((DEBUG_INFO, "%a: The FVB Header is not valid.\n", __FUNCTION__));
>
> + DEBUG ((
>
> + DEBUG_INFO,
>
> + "%a: Installing a correct one for this volume.\n",
>
> + __FUNCTION__
>
> + ));
>
> +
>
> + // Erase all the NorFlash that is reserved for variable storage
>
> + FvbNumLba = (PcdGet32 (PcdFlashNvStorageVariableSize) + PcdGet32 (PcdFlashNvStorageFtwWorkingSize) + PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;
>
> +
>
> + Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);
>
> + if (EFI_ERROR (Status)) {
>
> + return Status;
>
> + }
>
> +
>
> + // Install all appropriate headers
>
> + Status = InitializeFvAndVariableStoreHeaders (Instance);
>
> + if (EFI_ERROR (Status)) {
>
> + return Status;
>
> + }
>
> + }
>
> +
>
> + return Status;
>
> +}
>
next prev parent reply other threads:[~2022-10-19 12:53 UTC|newest]
Thread overview: 13+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-10-19 10:35 [PATCH edk2-platforms 0/4] Platform/ARM: clone ArmPlatformPkg's NorFlashDxe Ard Biesheuvel
2022-10-19 10:35 ` [PATCH edk2-platforms 1/4] Platform/ARM/BootMonFs: drop spurious dependency on ArmPlatformPkg Ard Biesheuvel
2022-10-19 12:46 ` Sami Mujawar
2022-10-19 10:35 ` [PATCH edk2-platforms 2/4] Platform/ARM: create local definition of NorFlashPlatformLib Ard Biesheuvel
2022-10-19 12:51 ` [edk2-devel] " Sunil V L
2022-10-19 12:52 ` Sami Mujawar
2022-10-19 12:56 ` [edk2-devel] " Ard Biesheuvel
2022-10-19 13:26 ` Sunil V L
2022-10-19 10:35 ` [PATCH edk2-platforms 3/4] Platform/ARM: clone NorFlashDxe from ArmPlatformPkg Ard Biesheuvel
2022-10-19 12:52 ` Sami Mujawar [this message]
2022-10-19 10:35 ` [PATCH edk2-platforms 4/4] Platform/ARM: switch to local version of NorFlashDxe drivers Ard Biesheuvel
2022-10-19 12:53 ` Sami Mujawar
2022-10-19 15:12 ` [PATCH edk2-platforms 0/4] Platform/ARM: clone ArmPlatformPkg's NorFlashDxe Ard Biesheuvel
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=27c6db3f-4739-6f1b-d669-f051457122cf@arm.com \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox