From: Leif Lindholm <leif.lindholm@linaro.org>
To: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: edk2-devel@lists.01.org, methavanitpong.pipat@socionext.com,
masahisa.kojima@linaro.org, masami.hiramatsu@linaro.org
Subject: Re: [PATCH edk2-platforms 13/14] Silicon/Socionext: add driver for SPI NOR flash
Date: Mon, 11 Sep 2017 20:13:01 +0100 [thread overview]
Message-ID: <20170911191301.wcvgqyylckmbiswl@bivouac.eciton.net> (raw)
In-Reply-To: <20170908182315.9591-14-ard.biesheuvel@linaro.org>
On Fri, Sep 08, 2017 at 07:23:14PM +0100, Ard Biesheuvel wrote:
> This imports the driver sources provided by Socionext for the FIP006
> SPI NOR flash device found on Synquacer SoCs. It has been slightly
> tweaked to bring it up to date with the changes made on the EDK2 side
> since it was forked.
>
> Contributed-under: TianoCore Contribution Agreement 1.1
> Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
> ---
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.dec | 31 +
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.inf | 78 ++
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Reg.h | 242 ++++
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashBlockIoDxe.c | 136 ++
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.c | 1313 ++++++++++++++++++++
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.h | 305 +++++
> Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashFvbDxe.c | 845 +++++++++++++
> 7 files changed, 2950 insertions(+)
>
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.dec b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.dec
> new file mode 100644
> index 000000000000..6c0ac807fd0b
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.dec
> @@ -0,0 +1,31 @@
> +## @file
> +# Socionext FIP006 High-Speed SPI Controller with NOR Flash Driver
> +#
> +# Copyright (c) 2017, Socionext Inc. All rights reserved.<BR>
> +#
> +# This program and the accompanying materials
> +# are licensed and made available under the terms and conditions of the BSD License
> +# which accompanies this distribution. The full text of the license may be found at
> +# http://opensource.org/licenses/bsd-license.php
> +#
> +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +#
> +##
> +
> +[Defines]
> + DEC_SPECIFICATION = 0x00010005
Bump.
> + PACKAGE_NAME = Fip006DxePkg
> + PACKAGE_GUID = ABC7870B-FE82-4DAD-8179-FEC5F5194FA0
> + PACKAGE_VERSION = 0.1
> +
> +[Guids]
> + gFip006DxeTokenSpaceGuid = {0x4D45399E, 0x98F9, 0x4127, {0x8F, 0xB9,0xF8, 0xDE, 0x22, 0xA1, 0x09, 0x2C}}
> +
> +[PcdsFixedAtBuild]
> + gFip006DxeTokenSpaceGuid.PcdFip006DxeRegBaseAddress|0x0|UINT32|0x00000001
> + gFip006DxeTokenSpaceGuid.PcdFip006DxeMemBaseAddress|0x0|UINT32|0x00000002
> + gFip006DxeTokenSpaceGuid.PcdN25qSlaveId|0x0|UINT8|0x00000003
> + gFip006DxeTokenSpaceGuid.PcdN25qBlockSize|256|UINT32|0x00000004
> + gFip006DxeTokenSpaceGuid.PcdN25qBlockCount|524288|UINT32|0x00000005
> +
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.inf b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.inf
> new file mode 100644
> index 000000000000..5727d4d937c9
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.inf
> @@ -0,0 +1,78 @@
> +## @file
> +# Socionext FIP006 High-Speed SPI Controller with NOR Flash Driver
> +#
> +# Copyright (c) 2017, Socionext Inc. All rights reserved.<BR>
> +#
> +# This program and the accompanying materials
> +# are licensed and made available under the terms and conditions of the BSD License
> +# which accompanies this distribution. The full text of the license may be found at
> +# http://opensource.org/licenses/bsd-license.php
> +#
> +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +#
> +##
> +
> +
> +[Defines]
> + INF_VERSION = 0x00010005
Bump.
> + BASE_NAME = Fip006Dxe
> + FILE_GUID = 44F7D21F-C36F-4766-BC5B-C72E97E6897B
> + MODULE_TYPE = DXE_RUNTIME_DRIVER
> + VERSION_STRING = 0.1
> + ENTRY_POINT = NorFlashInitialise
> +
> +[Sources]
> + NorFlashDxe.c
> + NorFlashBlockIoDxe.c
> + NorFlashFvbDxe.c
> +
> +[Packages]
> + ArmPlatformPkg/ArmPlatformPkg.dec
> + MdePkg/MdePkg.dec
> + MdeModulePkg/MdeModulePkg.dec
> + Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Dxe.dec
> +
> +[LibraryClasses]
> + BaseLib
> + BaseMemoryLib
> + DebugLib
> + DevicePathLib
> + DxeServicesTableLib
> + HobLib
> + IoLib
> + MemoryAllocationLib
> + NorFlashPlatformLib
> + UefiLib
> + UefiBootServicesTableLib
> + UefiDriverEntryPoint
> + UefiRuntimeLib
> + UefiRuntimeServicesTableLib
> +
> +[Guids]
> + gEfiAuthenticatedVariableGuid
> + gEfiEventVirtualAddressChangeGuid
> + gEfiSystemNvDataFvGuid
> + gEfiVariableGuid
> +
> +[Protocols]
> + gEfiBlockIoProtocolGuid
> + gEfiDevicePathProtocolGuid
> + gEfiDiskIoProtocolGuid
> + gEfiFirmwareVolumeBlockProtocolGuid
> +
> +[FixedPcd]
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase
> + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
> + gFip006DxeTokenSpaceGuid.PcdFip006DxeRegBaseAddress
> + gFip006DxeTokenSpaceGuid.PcdFip006DxeMemBaseAddress
> +
> +[Depex]
> + #
> + # NorFlashDxe must be loaded before VariableRuntimeDxe in case empty flash needs populating with default values
> + #
> + BEFORE gVariableRuntimeDxeFileGuid
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Reg.h b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Reg.h
> new file mode 100644
> index 000000000000..e515d967a1d7
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/Fip006Reg.h
> @@ -0,0 +1,242 @@
> +/** @file
> + Socionext FIP006 Register List
> +
> + Copyright (c) 2017, Socionext Inc. All rights reserved.<BR>
> + This program and the accompanying materials
> + are licensed and made available under the terms and conditions of the BSD License
> + which accompanies this distribution. The full text of the license may be found at
> + http://opensource.org/licenses/bsd-license.php
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#ifndef __EFI_FIP006_REG_H__
> +#define __EFI_FIP006_REG_H__
> +
> +#define FIP006_REG_MCTRL 0x00 // Module Control
> +typedef union {
> + UINT32 Raw : 32;
> + struct {
> + BOOLEAN MEN : 1;
> + BOOLEAN CSEN : 1;
> +#define MCTRL_CSEN_DIRECT 0
> +#define MCTRL_CSEN_CS 1
> + BOOLEAN CDSS : 1;
> +#define MCTRL_CDSS_IHCLK 0
> +#define MCTRL_CDSS_IPCLK 1
> + BOOLEAN MES : 1;
> +#define MCTRL_MES_READY 1
> + UINT8 : 4;
> + UINT8 : 8;
> + UINT8 : 8;
> + UINT8 : 8;
> + };
> +} FIP006_MCTRL;
I am generally not a fan of using bitfields like this...
> +
> +#define FIP006_REG_PCC0 0x04 // Peripheral Communication Control 0
> +#define FIP006_REG_PCC1 0x08 // Peripheral Communication Control 1
> +#define FIP006_REG_PCC2 0x0C // Peripheral Communication Control 2
> +#define FIP006_REG_PCC3 0x10 // Peripheral Communication Control 3
> +typedef union {
> + UINT32 Raw : 32;
> + struct {
> + BOOLEAN CPHA : 1;
> + BOOLEAN CPOL : 1;
> + BOOLEAN ACES : 1;
> + BOOLEAN RTM : 1;
> + BOOLEAN SSPOL : 1;
> + UINT8 SS2CD : 2;
> + BOOLEAN SDIR : 1;
> +#define PCC_SDIR_MS_BIT 0
> +#define PCC_SDIR_LS_BIT 1
> + BOOLEAN SENDIAN : 1;
> +#define PCC_SENDIAN_BIG 0
> +#define PCC_SENDIAN_LITTLE 1
> + UINT8 CDRS : 7;
> + BOOLEAN SAFESYNC : 1;
> + UINT8 WRDSEL : 4;
> + UINT8 RDDSEL : 2;
> + UINT8 : 1;
> + UINT8 : 8;
> + } Reg;
> +} FIP006_PCC;
> +typedef FIP006_PCC FIP006_PCC0, FIP006_PCC1, FIP006_PCC2, FIP006_PCC3;
> +
> +#define FIP006_REG_TXF 0x14 // Tx Interrupt Flag
> +#define TXF_TSSRS BIT6
> +#define TXF_TFMTS BIT5
> +#define TXF_TFLETS BIT4
> +#define TXF_TFUS BIT3
> +#define TXF_TFOS BIT2
> +#define TXF_TFES BIT1
> +#define TXF_TFFS BIT0
> +
> +#define FIP006_REG_TXE 0x18 // Tx Interrupt Enable
> +#define TXE_TSSRE BIT6
> +#define TXE_TFMTE BIT5
> +#define TXE_TFLETE BIT4
> +#define TXE_TFUE BIT3
> +#define TXE_TFOE BIT2
> +#define TXE_TFEE BIT1
> +#define TXE_TFFE BIT0
> +
> +#define FIP006_REG_TXC 0x1C // Tx Interrupt Clear
> +#define TXC_TSSRC BIT6
> +#define TXC_TFMTC BIT5
> +#define TXC_TFLETC BIT4
> +#define TXC_TFUC BIT3
> +#define TXC_TFOC BIT2
> +#define TXC_TFEC BIT1
> +#define TXC_TFFC BIT0
> +
> +#define FIP006_REG_RXF 0x20 // Rx Interrupt Flag
> +#define RXF_RSSRS BIT6
> +#define RXF_RFMTS BIT5
> +#define RXF_RFLETS BIT4
> +#define RXF_RFUS BIT3
> +#define RXF_RFOS BIT2
> +#define RXF_RFES BIT1
> +#define RXF_RFFS BIT0
> +
> +#define FIP006_REG_RXE 0x24 // Rx Interrupt Enable
> +#define RXE_RSSRE BIT6
> +#define RXE_RFMTE BIT5
> +#define RXE_RFLETE BIT4
> +#define RXE_RFUE BIT3
> +#define RXE_RFOE BIT2
> +#define RXE_RFEE BIT1
> +#define RXE_RFFE BIT0
> +
> +#define FIP006_REG_RXC 0x28 // Rx Interrupt Clear
> +#define RXC_RSSRC BIT6
> +#define RXC_RFMTC BIT5
> +#define RXC_RFLETC BIT4
> +#define RXC_RFUC BIT3
> +#define RXC_RFOC BIT2
> +#define RXC_RFEC BIT1
> +#define RXC_RFFC BIT0
> +
> +#define FIP006_REG_FAULTF 0x2C // Error Interrupt Status
> +#define FAULTF_DRCBSFS BIT4
> +#define FAULTF_DWCBSFS BIT3
> +#define FAULTF_PVFS BIT2
> +#define FAULTF_WAFS BIT1
> +#define FAULTF_UMAFS BIT0
> +
> +#define FIP006_REG_FAULTC 0x30 // Error Interrupt Clear
> +#define FAULTC_DRCBSFC BIT4
> +#define FAULTC_DWCBSFC BIT3
> +#define FAULTC_PVFC BIT2
> +#define FAULTC_WAFC BIT1
> +#define FAULTC_UMAFC BIT0
> +
> +#define FIP006_REG_DM_CFG 0x34 // Direct Mode DMA Configuration
> +#define DM_CFG_MSTARTEN BIT2
> +#define DM_CFG_SSDC BIT1
> +
> +#define FIP006_REG_DM_DMA 0x35 // Direct Mode DMA Enable
> +#define DM_DMA_TXDMAEN BIT1
> +#define DM_DMA_RXDMAEN BIT0
> +
> +#define FIP006_REG_DM_START 0x38 // Direct Mode Start Transmission
> +#define DM_START BIT0
> +#define FIP006_REG_DM_STOP 0x39 // Direct Mode Stop Transmission
> +#define DM_STOP BIT0
> +
> +#define FIP006_REG_DM_PSEL 0x3A // Direct Mode Peripheral Select
> +#define DM_PSEL (BIT1 | BIT0)
> +
> +#define FIP006_REG_DM_TRP 0x3B // Direct Mode Transmission Protocol
> +#define DM_TRP (BIT3 | BIT2 | BIT1 | BIT0)
> +
> +#define FIP006_REG_DM_BCC 0x3C // Direct Mode Byte Count Control
> +#define FIP006_REG_DM_BCS 0x3E // Direct Mode Byte Count Status
> +
> +#define FIP006_REG_DM_STATUS 0x40 // Direct Mode Status
> +#define DM_STATUS_TXFLEVEL (BIT20 | BIT19 | BIT18 | BIT17 | BIT16)
> +#define DM_STATUS_RXFLEVEL (BIT20 | BIT19 | BIT18 | BIT17 | BIT16)
> +#define DM_STATUS_TXACTIVE BIT1
> +#define DM_STATUS_RXACTIVE BIT0
> +
> +#define FIP006_REG_FIFO_CFG 0x4C // FIFO Configuration
> +#define FIFO_CFG_TXFLSH BIT12
> +#define FIFO_CFG_RXFLSH BIT11
> +#define FIFO_CFG_TXCTRL BIT10
> +#define FIFO_CFG_FWIDTH (BIT9 | BIT8)
> +#define FIFO_CFG_TXFTH (BIT7 | BIT6 | BIT5 | BIT4)
> +#define FIFO_CFG_RXFTH (BIT3 | BIT2 | BIT1 | BIT0)
> +
> +#define FIP006_REG_FIFO_TX 0x50 // 16 32-bit Tx FIFO
> +#define FIP006_REG_FIFO_RX 0x90 // 16 32-bit Rx FIFO
> +
> +#define FIP006_REG_CS_CFG 0xD0 // Command Sequencer Configuration
> +typedef union {
> + UINT32 Raw : 32;
> + struct {
> + BOOLEAN SRAM : 1;
> +#define CS_CFG_SRAM_RO 0
> +#define CS_CFG_SRAM_RW 1
> + UINT8 MBM : 2;
> +#define CS_CFG_MBM_SINGLE 0
> +#define CS_CFG_MBM_DUAL 1
> +#define CS_CFG_MBM_QUAD 2
> + BOOLEAN SPICHNG : 1;
> + BOOLEAN BOOTEN : 1;
> + BOOLEAN BSEL : 1;
> + UINT8 : 2;
> + BOOLEAN SSEL0EN : 1;
> + BOOLEAN SSEL1EN : 1;
> + BOOLEAN SSEL2EN : 1;
> + BOOLEAN SSEL3EN : 1;
> + UINT8 : 4;
> + BOOLEAN MSEL : 4;
> + UINT8 : 4;
> + UINT8 : 8;
> + } Reg;
> +} FIP006_CS_CFG;
> +
> +#define FIP006_REG_CS_ITIME 0xD4 // Command Sequencer Idle Timer
> +typedef union {
> + UINT32 Raw : 32;
> + struct {
> + UINT16 ITIME : 16;
> + UINT16 : 16;
> + } Reg;
> +} FIP006_CS_ITIME;
> +#define FIP006_REG_CS_AEXT 0xD8 // Command Sequencer Address Extension
> +typedef union {
> + UINT32 Raw : 32;
> + struct {
> + UINT16 : 13;
> + UINT32 AEXT : 19;
> + } Reg;
> +} FIP006_CS_AEXT;
> +
> +#define FIP006_REG_CS_RD 0xDC // Command Sequencer Read Control
> +#define CS_RD_DEPTH 8
> +#define FIP006_REG_CS_WR 0xEC // Command Sequencer Write Control
> +#define CS_WR_DEPTH 8
> +typedef union {
> + UINT16 Raw : 16;
> + struct {
> + BOOLEAN DEC : 1;
> + UINT8 TRP : 2;
> + BOOLEAN CONT : 1;
> + UINT8 : 4;
> + union {
> + UINT8 Data : 8;
> + struct {
> + UINT8 Data : 3;
> + UINT8 : 5;
> + } Cmd;
> + } Payload;
> + } Reg;
> +} FIP006_CS_CMD;
> +typedef FIP006_CS_CMD FIP006_CS_RD, FIP006_CS_WR;
> +
> +#define FIP006_REG_MID 0xFC // Command Sequencer Module ID
> +typedef UINT32 FIP006_MID;
> +
> +#endif
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashBlockIoDxe.c b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashBlockIoDxe.c
> new file mode 100644
> index 000000000000..b325d1721aa4
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashBlockIoDxe.c
> @@ -0,0 +1,136 @@
> +/** @file NorFlashBlockIoDxe.c
> +
> + Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>
Add Linaro copyright?
> +
> + This program and the accompanying materials
> + are licensed and made available under the terms and conditions of the BSD License
> + which accompanies this distribution. The full text of the license may be found at
> + http://opensource.org/licenses/bsd-license.php
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/UefiBootServicesTableLib.h>
> +
> +#include "NorFlashDxe.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, 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);
Space before (?
> +
> + DEBUG ((DEBUG_BLKIO,
> + "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes "
> + "(%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));
> +
> + if( !This->Media->MediaPresent ) {
And drop superflous whitespace.
> + 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/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.c b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.c
> new file mode 100644
> index 000000000000..ad004ddf03b3
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.c
> @@ -0,0 +1,1313 @@
> +/** @file NorFlashDxe.c
> +
> + Copyright (c) 2017, Socionext Inc. All rights reserved.<BR>
> + Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
Add copyright notice?
> +
> + This program and the accompanying materials are licensed and made available
> + under the terms and conditions of the BSD License which accompanies this
> + distribution. The full text of the license may be found at
> + http://opensource.org/licenses/bsd-license.php
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#include <Library/UefiLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UefiBootServicesTableLib.h>
> +#include <Library/PcdLib.h>
> +
Sort alphabetically?
> +#include "NorFlashDxe.h"
> +
> +STATIC EFI_EVENT mNorFlashVirtualAddrChangeEvent;
> +
> +//
> +// Global variable declarations
> +//
> +STATIC NOR_FLASH_INSTANCE **mNorFlashInstances;
> +STATIC UINT32 mNorFlashDeviceCount;
> +
> +STATIC CONST UINT16 mFip006NullCmdSeq[] = {
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1),
> + CSDC (0x07, 0, CSDC_TRP_MBM, 1)
> +};
> +
> +STATIC CONST CSDC_DEFINITION mN25qCSDCDefTable[] = {
> + // Register Operations
> + { 0x05, FALSE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0x01, FALSE, FALSE, FALSE, TRUE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0xE8, TRUE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0x70, FALSE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0xB5, FALSE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0x85, FALSE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0x65, FALSE, FALSE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + // Read Operations
> + { 0x13, TRUE, TRUE, FALSE, FALSE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + // Write Operations
> + { 0x02, TRUE, FALSE, FALSE, TRUE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> + { 0x32, TRUE, FALSE, FALSE, TRUE, CS_CFG_MBM_QUAD, CSDC_TRP_SINGLE },
> + // Erase Operations
> + { 0xD8, FALSE, FALSE, FALSE, TRUE, CS_CFG_MBM_SINGLE, CSDC_TRP_SINGLE },
> +};
> +
> +STATIC
> +EFI_STATUS
> +NorFlashSetHostCSDC (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN BOOLEAN ReadWrite,
> + IN CONST UINT16 CSDC[8]
> + )
> +{
> + EFI_PHYSICAL_ADDRESS Dst;
> + UINTN Index;
> +
> + Dst = Instance->HostRegisterBaseAddress
> + + (ReadWrite ? FIP006_REG_CS_WR : FIP006_REG_CS_RD);
> + for (Index = 0; Index < 8; Index++) {
ARRAY_SIZE instead of 8?
> + MmioWrite16 (Dst + (Index << 1), CSDC[Index]);
> + }
> + return EFI_SUCCESS;
> +}
> +
> +STATIC
> +CONST CSDC_DEFINITION *
> +NorFlashGetCmdDef (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINT8 Code
> + )
> +{
> + CONST CSDC_DEFINITION *Cmd;
> + UINTN Index;
> +
> + Cmd = NULL;
> + for (Index = 0; Index < Instance->CmdTableSize; Index++) {
> + if (Code == Instance->CmdTable[Index].Code) {
> + Cmd = &Instance->CmdTable[Index];
> + break;
> + }
> + }
> + return Cmd;
> +}
> +
> +STATIC
> +EFI_STATUS
> +GenCSDC (
> + IN UINT8 Cmd,
> + IN BOOLEAN AddrAccess,
> + IN BOOLEAN AddrMode4Byte,
> + IN BOOLEAN HighZ,
> + IN UINT8 TransferMode,
> + OUT UINT16 CmdSeq[8]
> + )
> +{
> + UINTN Index;
> +
> + if (!CmdSeq) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + Index = 0;
> + CopyMem (CmdSeq, mFip006NullCmdSeq, 8 * sizeof (UINT16));
ARRAY_SIZE?
> +
> + CmdSeq[Index++] = CSDC (Cmd, 0, TransferMode, 0);
> + if (AddrAccess) {
> + if (AddrMode4Byte) {
> + CmdSeq[Index++] = CSDC (0x03, 0, TransferMode, 1);
> + }
> + CmdSeq[Index++] = CSDC (0x02, 0, TransferMode, 1);
> + CmdSeq[Index++] = CSDC (0x01, 0, TransferMode, 1);
> + CmdSeq[Index++] = CSDC (0x00, 0, TransferMode, 1);
> + }
> + if (HighZ) {
> + CmdSeq[Index++] = CSDC (0x04, 0, TransferMode, 1);
Can anythng be done about these magic hex values?
> + }
> +
> + return EFI_SUCCESS;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashSetHostCommand (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINT8 Code
> + )
> +{
> + CONST CSDC_DEFINITION *Cmd;
> + UINT16 CSDC[8];
> +
> + Cmd = NorFlashGetCmdDef(Instance, Code);
> + if (Cmd == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> + GenCSDC (
> + Cmd->Code,
> + Cmd->AddrAccess,
> + Cmd->AddrMode4Byte,
> + Cmd->HighZ,
> + Cmd->CsdcTrp,
> + CSDC
> + );
> + NorFlashSetHostCSDC (Instance, Cmd->ReadWrite, CSDC);
> + return EFI_SUCCESS;
> +}
> +
> +STATIC
> +UINT8
> +NorFlashReadStatusRegister (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN SR_Address
> + )
> +{
> + UINT8 StatusRegister;
> +
> + NorFlashSetHostCommand (Instance, 0x05);
> + StatusRegister = NOR_FLASH_READ_BYTE (Instance, 0);
> + NorFlashSetHostCommand (Instance, 0x13);
Magic values?
> + return StatusRegister;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashWaitProgramErase (
> + IN NOR_FLASH_INSTANCE *Instance
> + )
> +{
> + DEBUG ((DEBUG_BLKIO, "NorFlashWaitProgramErase()\n"));
> +
> + NorFlashSetHostCommand (Instance, 0x70);
> + while ((NOR_FLASH_READ_BYTE (Instance, 0) & BIT7) == 0);
> + NorFlashSetHostCommand (Instance, 0x13);
Magic values? (Including BIT7.)
> + return EFI_SUCCESS;
> +}
> +
> +// TODO: implement lock checking
Is this a TODO for this series, or inherited?
> +STATIC
> +BOOLEAN
> +NorFlashBlockIsLocked (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN BlockAddress
> + )
> +{
> + return FALSE;
> +}
> +
> +// TODO: implement sector unlocking
> +STATIC
> +EFI_STATUS
> +NorFlashUnlockSingleBlock (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN BlockAddress
> + )
> +{
> + return EFI_SUCCESS;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashUnlockSingleBlockIfNecessary (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN BlockAddress
> + )
> +{
> + EFI_STATUS Status;
> +
> + Status = EFI_SUCCESS;
> +
> + if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {
> + Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);
> + }
> +
> + return Status;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashEnableWrite (
> + IN NOR_FLASH_INSTANCE *Instance
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 StatusRegister;
> + UINTN Retry;
> +
> + DEBUG ((DEBUG_BLKIO, "NorFlashEnableWrite()\n"));
> +
> + Status = EFI_DEVICE_ERROR;
> + Retry = 100;
Are 100 retries really necessary?
Polling 100 times to wait for a status flag to flip is one
thing. Repeating a command 100 times is something else.
> +
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> + while (Retry > 0 && EFI_ERROR (Status)) {
> + NOR_FLASH_WRITE_BYTE (Instance, 0, 0x06);
> + StatusRegister = NorFlashReadStatusRegister (Instance, 0);
> + Status = (StatusRegister & BIT1) ? EFI_SUCCESS : EFI_DEVICE_ERROR;
Magic values? (0x06 and BIT1.)
> + Retry--;
> + }
> + return Status;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashDisableWrite (
> + IN NOR_FLASH_INSTANCE *Instance
> + )
> +{
> + EFI_STATUS Status;
> + UINT8 StatusRegister;
> + UINTN Retry;
> +
> + DEBUG ((DEBUG_BLKIO, "NorFlashDisableWrite()\n"));
> +
> + Status = EFI_DEVICE_ERROR;
> + Retry = 10;
And why just (but still) 10 when going the other way.
> +
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> + while (Retry > 0 && EFI_ERROR (Status)) {
> + NOR_FLASH_WRITE_BYTE (Instance, 0, 0x04);
> + StatusRegister = NorFlashReadStatusRegister (Instance, 0);
> + Status = (StatusRegister & BIT1) ? EFI_DEVICE_ERROR : EFI_SUCCESS;
Magic?
> + Retry--;
> + }
> + return Status;
> +}
> +
> +/**
> + * The following function presumes that the block has already been unlocked.
> + **/
> +STATIC
> +EFI_STATUS
> +NorFlashEraseSingleBlock (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN BlockAddress
> + )
> +{
> + UINT16 Sector;
> +
> + DEBUG ((DEBUG_BLKIO, "NorFlashEraseSingleBlock(BlockAddress=0x%08x)\n",
> + BlockAddress));
> +
> + Sector = (BlockAddress - Instance->RegionBaseAddress) /
> + Instance->Media.BlockSize;
> + Sector += Instance->OffsetLba;
> +
> + if (EFI_ERROR (NorFlashEnableWrite (Instance))) {
> + return EFI_DEVICE_ERROR;
> + }
> +
> + // Erase a block
> + NorFlashSetHostCommand (Instance, 0xD8);
Magic?
> + *(UINT16*) Instance->RegionBaseAddress = SwapBytes16 (Sector);
Space after cast.
> + NorFlashWaitProgramErase (Instance);
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> +
> + NorFlashDisableWrite (Instance);
> + return EFI_SUCCESS;
> +}
> +
> +/**
> + * 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;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashWriteSingleWord (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN WordAddress,
> + IN UINT32 WriteData
> + )
> +{
> + EFI_STATUS Status;
> +
> + DEBUG ((DEBUG_BLKIO,
> + "NorFlashWriteSingleWord(WordAddress=0x%08x, WriteData=0x%08x)\n",
> + WordAddress, WriteData));
> +
> + Status = EFI_SUCCESS;
> +
> + if (EFI_ERROR (NorFlashEnableWrite (Instance))) {
> + return EFI_DEVICE_ERROR;
> + }
> + NorFlashSetHostCommand (Instance, 0x02);
Magic?
> + *(UINT32*) WordAddress = WriteData;
Space after cast.
> + NorFlashWaitProgramErase (Instance);
> +
> + NorFlashDisableWrite (Instance);
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> + return Status;
> +}
> +
> +STATIC
> +EFI_STATUS
> +NorFlashWriteFullBlock (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINT32 *DataBuffer,
> + IN UINT32 BlockSizeInWords
> + )
> +{
> + EFI_STATUS Status;
> + UINTN WordAddress;
> + UINT32 WordIndex;
> + UINTN BlockAddress;
> + EFI_TPL OriginalTPL;
> +
> + 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;
> + }
> +
> + for (WordIndex=0;
> + WordIndex < BlockSizeInWords;
> + WordIndex++, DataBuffer++, WordAddress += 4) {
> + Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
> + if (EFI_ERROR (Status)) {
> + goto EXIT;
> + }
> + }
> +
> +EXIT:
> + if (!EfiAtRuntime ()) {
> + // Interruptions can resume.
I would probably go with "Re-enable pre-emption" :)
> + 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
> +NorFlashWriteBlocks (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN BufferSizeInBytes,
> + IN VOID *Buffer
> + )
> +{
> + UINT32 *pWriteBuffer;
> + EFI_STATUS Status = EFI_SUCCESS;
> + EFI_LBA CurrentBlock;
> + UINT32 BlockSizeInWords;
> + UINT32 NumBlocks;
> + UINT32 BlockCount;
> +
> + // The buffer must be valid
> + if (Buffer == NULL) {
> + return EFI_INVALID_PARAMETER;
> + }
> +
> + 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 += 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;
> +}
> +
> +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
> + NorFlashSetHostCommand (Instance, 0x13);
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> +
> + // Readout the data
> + CopyMem(Buffer, (UINTN *)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) {
Could fit onto one line with a local variable for "Lba * Instance->Media.Blocksize".
> + 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
> + NorFlashSetHostCommand (Instance, 0x13);
Magic?
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> +
> + // Readout the data
> + CopyMem (Buffer, (UINTN *)(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;
Preferable to avoid the ambiguous 'word' moniker.
> +
> + PrevBlockAddress = 0;
> +
> + if (!Instance->Initialized && Instance->Initialize) {
> + Instance->Initialize(Instance);
> + }
> +
> + 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.
'word' is ambiguous here. 32-bit is probably correct.
> + 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
!word
> + 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.
!word
> + 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_CHNAGED The MediaId does not matched the current device.
> + @retval EFI_INVALID_PARAMETER The read request contains device addresses that
> + are not valid for the device.
> +
> +**/
> +STATIC
> +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_CHNAGED The MediaId does not matched the current device.
> + @retval EFI_INVALID_PARAMETER The write request contains device addresses that
> + are not valid for the device.
> +
> +**/
> +STATIC
> +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);
Space after cast.
> +
> + 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;
Space after cast.
> + Lba++;
> + BlockOffset = 0;
> + WriteSize = MIN (RemainingBytes, BlockSize);
> + } while (RemainingBytes);
> +
> + return Status;
> +}
> +
> +STATIC CONST NOR_FLASH_INSTANCE mNorFlashInstanceTemplate = {
> + NOR_FLASH_SIGNATURE, // Signature
> + NULL, // Handle ... NEED TO BE FILLED
> +
> + FALSE, // Initialized
> + NULL, // Initialize
> +
> + 0, // HostRegisterBaseAddress ... NEED TO BE FILLED
> + 0, // DeviceBaseAddress ... NEED TO BE FILLED
> + 0, // RegionBaseAddress ... NEED TO BE FILLED
> + 0, // Size ... NEED TO BE FILLED
> + 0, // StartLba
> + 0, // OffsetLba
> +
> + {
> + 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
> + },
> +
> + FALSE, // SupportFvb ... NEED TO BE FILLED
> + {
> + FvbGetAttributes, // GetAttributes
> + FvbSetAttributes, // SetAttributes
> + FvbGetPhysicalAddress, // GetPhysicalAddress
> + FvbGetBlockSize, // GetBlockSize
> + FvbRead, // Read
> + FvbWrite, // Write
> + FvbEraseBlocks, // EraseBlocks
> + NULL, //ParentHandle
> + }, // FvbProtoccol;
> +
> + NULL, // ShadowBuffer
> + {
> + {
> + {
> + HARDWARE_DEVICE_PATH,
> + HW_VENDOR_DP,
> + {
> + (UINT8)sizeof(VENDOR_DEVICE_PATH),
> + (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8)
Space after sizeof?
> + }
> + },
> + { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } },
> + },
> + {
> + END_DEVICE_PATH_TYPE,
> + END_ENTIRE_DEVICE_PATH_SUBTYPE,
> + { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
> + }
> + } // DevicePath
> +};
> +
> +STATIC
> +EFI_STATUS
> +NorFlashCreateInstance (
> + IN UINTN HostRegisterBase,
> + IN UINTN NorFlashDeviceBase,
> + IN UINTN NorFlashRegionBase,
> + IN UINTN NorFlashSize,
> + IN UINT32 MediaId,
> + IN UINT32 BlockSize,
> + IN BOOLEAN SupportFvb,
> + IN CONST GUID *NorFlashGuid,
> + IN CONST CSDC_DEFINITION *CommandTable,
> + IN UINTN CommandTableSize,
> + OUT NOR_FLASH_INSTANCE** NorFlashInstance
> + )
> +{
> + EFI_STATUS Status;
> + NOR_FLASH_INSTANCE* Instance;
> +
> + ASSERT(NorFlashInstance != NULL);
> +
> + Instance = AllocateRuntimeCopyPool (sizeof mNorFlashInstanceTemplate,
Parentheses with sizeof.
> + &mNorFlashInstanceTemplate);
> + if (Instance == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + Instance->HostRegisterBaseAddress = HostRegisterBase;
> + Instance->DeviceBaseAddress = NorFlashDeviceBase;
> + Instance->RegionBaseAddress = NorFlashRegionBase;
> + Instance->Size = NorFlashSize;
> +
> + Instance->BlockIoProtocol.Media = &Instance->Media;
> + Instance->Media.MediaId = MediaId;
> + Instance->Media.BlockSize = BlockSize;
> + Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;
Spaces around -.
> + Instance->OffsetLba = (NorFlashRegionBase - NorFlashDeviceBase) / BlockSize;
> +
> + CopyGuid (&Instance->DevicePath.Vendor.Guid, NorFlashGuid);
> +
> + Instance->CmdTable = CommandTable;
> + Instance->CmdTableSize = CommandTableSize;
> +
> + Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);;
Double ;.
> + if (Instance->ShadowBuffer == NULL) {
> + return EFI_OUT_OF_RESOURCES;
> + }
> +
> + NorFlashReset (Instance);
> + if (SupportFvb) {
> + Instance->SupportFvb = TRUE;
> + Instance->Initialize = NorFlashFvbInitialize;
> +
> + Status = gBS->InstallMultipleProtocolInterfaces (
> + &Instance->Handle,
> + &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
> + &gEfiBlockIoProtocolGuid, &Instance->BlockIoProtocol,
> + &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,
> + NULL
> + );
> + if (EFI_ERROR (Status)) {
> + FreePool (Instance);
> + return Status;
> + }
> + } else {
> + Instance->Initialized = TRUE;
> +
> + 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;
> +}
> +
> +EFI_STATUS
> +NorFlashReset (
> + IN NOR_FLASH_INSTANCE *Instance
> + )
> +{
> + FIP006_CS_CFG CsCfg;
> +
> + DEBUG ((DEBUG_BLKIO, "NorFlashReset()\n"));
> + NOR_FLASH_GET_HOST_REG(Instance, CS_CFG, CsCfg);
Missing space.
> + CsCfg.Reg.MBM = CS_CFG_MBM_SINGLE;
> + CsCfg.Reg.SRAM = CS_CFG_SRAM_RW;
> + NOR_FLASH_SET_HOST_REG(Instance, CS_CFG, CsCfg);
Missing space.
> + NorFlashSetHostCommand (Instance, 0x13);
Magic?
> + NorFlashSetHostCSDC (Instance, TRUE, mFip006NullCmdSeq);
> + 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
> +**/
> +STATIC
> +VOID
> +EFIAPI
> +NorFlashVirtualNotifyEvent (
> + IN EFI_EVENT Event,
> + IN VOID *Context
> + )
> +{
> + UINTN Index;
> +
> + for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
> + EfiConvertPointer (0x0,
> + (VOID**)&mNorFlashInstances[Index]->HostRegisterBaseAddress);
> + 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);
> + }
> +
> + EfiConvertPointer (0x0, (VOID**)&mNorFlashInstances[Index]->CmdTable);
> + }
> +
> + return;
> +}
> +
> +EFI_STATUS
> +EFIAPI
> +NorFlashInitialise (
> + IN EFI_HANDLE ImageHandle,
> + IN EFI_SYSTEM_TABLE *SystemTable
> + )
> +{
> + EFI_STATUS Status;
> + EFI_PHYSICAL_ADDRESS HostRegisterBaseAddress;
> + UINT32 Index;
> + NOR_FLASH_DESCRIPTION* NorFlashDevices;
> + BOOLEAN ContainVariableStorage;
> +
> + // Register HSSPI FIP006 register region
> + HostRegisterBaseAddress = PcdGet32 (PcdFip006DxeRegBaseAddress);
> +
> + Status = gDS->AddMemorySpace (
> + EfiGcdMemoryTypeMemoryMappedIo,
> + HostRegisterBaseAddress, SIZE_4KB,
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
> + );
> + ASSERT_EFI_ERROR (Status);
> +
> + Status = gDS->SetMemorySpaceAttributes (
> + HostRegisterBaseAddress, SIZE_4KB,
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME);
> + ASSERT_EFI_ERROR (Status);
> +
> + Status = NorFlashPlatformInitialization ();
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR,
> + "NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
> + return Status;
> + }
> +
> + // Initialize NOR flash instances
> + Status = NorFlashPlatformGetDevices (&NorFlashDevices, &mNorFlashDeviceCount);
> + if (EFI_ERROR (Status)) {
> + DEBUG ((DEBUG_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));
> + return Status;
> + }
> +
> + if (mNorFlashDeviceCount > 1) {
> + DEBUG ((DEBUG_WARN, "%a: device count exceeds 1\n", __FUNCTION__));
> + DEBUG ((DEBUG_WARN, "%a: use only first device\n", __FUNCTION__));
> + mNorFlashDeviceCount = 1;
> + }
> + mNorFlashInstances = AllocateRuntimePool (sizeof(NOR_FLASH_INSTANCE*) *
> + mNorFlashDeviceCount);
> +
> + for (Index = 0; Index < mNorFlashDeviceCount; Index++) {
> + // Check if this NOR Flash device contain the variable storage region
> + ContainVariableStorage =
> + (NorFlashDevices[Index].RegionBaseAddress <=
> + PcdGet32 (PcdFlashNvStorageVariableBase)) &&
> + (PcdGet32 (PcdFlashNvStorageVariableBase) +
> + PcdGet32 (PcdFlashNvStorageVariableSize) <=
> + NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
> +
> + Status = NorFlashCreateInstance (
> + HostRegisterBaseAddress,
> + NorFlashDevices[Index].DeviceBaseAddress,
> + NorFlashDevices[Index].RegionBaseAddress,
> + NorFlashDevices[Index].Size,
> + Index,
> + NorFlashDevices[Index].BlockSize,
> + ContainVariableStorage,
> + &NorFlashDevices[Index].Guid,
> + mN25qCSDCDefTable,
> + ARRAY_SIZE (mN25qCSDCDefTable),
> + &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;
> +}
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.h b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.h
> new file mode 100644
> index 000000000000..ca82bda6dfb7
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashDxe.h
> @@ -0,0 +1,305 @@
> +/** @file NorFlashDxe.h
> +
> + Copyright (c) 2017, Socionext Inc. All rights reserved.<BR>
> + Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
> +
> + This program and the accompanying materials
> + are licensed and made available under the terms and conditions of the BSD License
> + which accompanies this distribution. The full text of the license may be found at
> + http://opensource.org/licenses/bsd-license.php
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#ifndef __NOR_FLASH_DXE_H__
> +#define __NOR_FLASH_DXE_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>
> +#include <Library/DxeServicesTableLib.h>
Can these be sorted.
> +
> +#include "Fip006Reg.h"
> +
> +#define NOR_FLASH_ERASE_RETRY 10
Hmm, so we have a define for RETRY but not enable/disable write?
> +
> +#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + (UINTN)((Lba) * LbaSize) )
Needs additional parentheses around (BaseAddr) and (LbaSize).
> +
> +#define NOR_FLASH_READ_BYTE(Instance, Addr) \
> + (((UINT8*) Instance->RegionBaseAddress + Addr)[0])
(Instance), (Addr)
> +
> +#define NOR_FLASH_WRITE_BYTE(Instance, Addr, Src) \
> + do { \
> + ((UINT8*) Instance->RegionBaseAddress + Addr)[0] = Src; \
(Instance), (Addr)
> + } while (0)
> +
> +#define NOR_FLASH_GET_HOST_REG(Instance, Reg, Dst) \
> + do { \
> + Dst.Raw = MmioRead32(Instance->HostRegisterBaseAddress + FIP006_REG_##Reg); \
(Dst), (Instance)
> + } while (0)
> +
> +#define NOR_FLASH_SET_HOST_REG(Instance, Reg, Src) \
> + do { \
> + MmioWrite32 (Instance->HostRegisterBaseAddress + FIP006_REG_##Reg, Src.Raw); \
(Instance), (Src)
> + } while (0)
> +
> +#define NOR_FLASH_SIGNATURE SIGNATURE_32('S', 'n', 'o', 'r')
> +#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)
(a) x3
> +
> +#define CSDC(Data, Cont, Trp, Dec) \
> + ((Data << 8) | (Cont << 3) | (Trp << 1) | Dec)
(Data), (Cont), (Trp), (Dec)
> +#define CSDC_TRP_MBM 0
> +#define CSDC_TRP_DUAL 1
> +#define CSDC_TRP_QUAD 2
> +#define CSDC_TRP_SINGLE 3
> +
> +typedef struct {
> + UINT8 Code;
> + BOOLEAN AddrAccess;
> + BOOLEAN AddrMode4Byte;
> + BOOLEAN HighZ;
> + BOOLEAN ReadWrite;
> + UINT8 CscfgMbm;
> + UINT8 CsdcTrp;
> +} CSDC_DEFINITION;
> +
> +typedef struct _NOR_FLASH_INSTANCE NOR_FLASH_INSTANCE;
> +
> +typedef EFI_STATUS (*NOR_FLASH_INITIALIZE) (NOR_FLASH_INSTANCE* Instance);
> +
> +typedef struct {
> + VENDOR_DEVICE_PATH Vendor;
> + EFI_DEVICE_PATH_PROTOCOL End;
> +} NOR_FLASH_DEVICE_PATH;
> +
> +struct _NOR_FLASH_INSTANCE {
> + UINT32 Signature;
> + EFI_HANDLE Handle;
> +
> + BOOLEAN Initialized;
> + NOR_FLASH_INITIALIZE Initialize;
> +
> + UINTN HostRegisterBaseAddress;
> + UINTN DeviceBaseAddress;
> + UINTN RegionBaseAddress;
> + UINTN Size;
> + EFI_LBA StartLba;
> + EFI_LBA OffsetLba;
> +
> + EFI_BLOCK_IO_PROTOCOL BlockIoProtocol;
> + EFI_BLOCK_IO_MEDIA Media;
> + EFI_DISK_IO_PROTOCOL DiskIoProtocol;
> +
> + BOOLEAN SupportFvb;
> + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;
> + VOID* ShadowBuffer;
> +
> + NOR_FLASH_DEVICE_PATH DevicePath;
> +
> + CONST CSDC_DEFINITION *CmdTable;
> + UINTN CmdTableSize;
> +};
> +
> +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
> +);
> +
> +//
> +// NorFlashFvbDxe.c
> +//
> +
> +EFI_STATUS
> +EFIAPI
> +NorFlashFvbInitialize (
> + IN NOR_FLASH_INSTANCE* Instance
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbGetAttributes(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + OUT EFI_FVB_ATTRIBUTES_2 *Attributes
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbSetAttributes(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbGetPhysicalAddress(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + OUT EFI_PHYSICAL_ADDRESS *Address
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbGetBlockSize(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + IN EFI_LBA Lba,
> + OUT UINTN *BlockSize,
> + OUT UINTN *NumberOfBlocks
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbRead(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + IN EFI_LBA Lba,
> + IN UINTN Offset,
> + IN OUT UINTN *NumBytes,
> + IN OUT UINT8 *Buffer
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbWrite(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + IN EFI_LBA Lba,
> + IN UINTN Offset,
> + IN OUT UINTN *NumBytes,
> + IN UINT8 *Buffer
> + );
> +
> +EFI_STATUS
> +EFIAPI
> +FvbEraseBlocks(
> + IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
> + ...
> + );
> +
> +//
> +// NorFlashDxe.c
> +//
> +
> +EFI_STATUS
> +NorFlashUnlockAndEraseSingleBlock (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN UINTN BlockAddress
> + );
> +
> +EFI_STATUS
> +NorFlashWriteSingleBlock (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN Offset,
> + IN OUT UINTN *NumBytes,
> + IN UINT8 *Buffer
> + );
> +
> +EFI_STATUS
> +NorFlashWriteBlocks (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN BufferSizeInBytes,
> + IN VOID *Buffer
> + );
> +
> +EFI_STATUS
> +NorFlashReadBlocks (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN BufferSizeInBytes,
> + OUT VOID *Buffer
> + );
> +
> +EFI_STATUS
> +NorFlashRead (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN Offset,
> + IN UINTN BufferSizeInBytes,
> + OUT VOID *Buffer
> + );
> +
> +EFI_STATUS
> +NorFlashWrite (
> + IN NOR_FLASH_INSTANCE *Instance,
> + IN EFI_LBA Lba,
> + IN UINTN Offset,
> + IN OUT UINTN *NumBytes,
> + IN UINT8 *Buffer
> + );
> +
> +EFI_STATUS
> +NorFlashReset (
> + IN NOR_FLASH_INSTANCE *Instance
> + );
> +
> +#endif /* __NOR_FLASH_DXE_H__ */
> diff --git a/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashFvbDxe.c b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashFvbDxe.c
> new file mode 100644
> index 000000000000..b63d778d84bc
> --- /dev/null
> +++ b/Silicon/Socionext/Synquacer/Drivers/Fip006Dxe/NorFlashFvbDxe.c
> @@ -0,0 +1,845 @@
> +/*++ @file NorFlashFvbDxe.c
> +
> + Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
> +
> + This program and the accompanying materials are licensed and made available
> + under the terms and conditions of the BSD License which accompanies this
> + distribution. The full text of the license may be found at
> + http://opensource.org/licenses/bsd-license.php
> +
> + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> + --*/
> +
> +#include <PiDxe.h>
> +
> +#include <Library/PcdLib.h>
> +#include <Library/BaseLib.h>
> +#include <Library/HobLib.h>
> +#include <Library/UefiLib.h>
> +#include <Library/BaseMemoryLib.h>
> +#include <Library/MemoryAllocationLib.h>
> +#include <Library/UefiBootServicesTableLib.h>
> +
> +#include <Guid/VariableFormat.h>
> +#include <Guid/SystemNvDataGuid.h>
Alphabetically sorted?
> +
> +#include "NorFlashDxe.h"
> +
> +STATIC EFI_EVENT mFvbVirtualAddrChangeEvent;
> +STATIC 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
> +
> +**/
> +STATIC
> +EFI_STATUS
> +InitializeFvAndVariableStoreHeaders (
> + IN NOR_FLASH_INSTANCE *Instance
> + )
> +{
> + EFI_STATUS Status;
> + VOID* Headers;
> + UINTN HeadersLength;
> + EFI_FIRMWARE_VOLUME_HEADER *FirmwareVolumeHeader;
> + VARIABLE_STORE_HEADER *VariableStoreHeader;
> + UINTN BlockSize;
> +
> + if (!Instance->Initialized && Instance->Initialize) {
> + Instance->Initialize (Instance);
> + }
> +
> + HeadersLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) +
> + sizeof(EFI_FV_BLOCK_MAP_ENTRY) +
> + sizeof(VARIABLE_STORE_HEADER);
> + Headers = AllocateZeroPool(HeadersLength);
> +
> + BlockSize = Instance->Media.BlockSize;
> +
> + // FirmwareVolumeHeader->FvLength is declared to have the Variable area
> + // AND the FTW working area AND the FTW Spare contiguous.
> + ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) +
> + PcdGet32(PcdFlashNvStorageVariableSize) ==
> + PcdGet32(PcdFlashNvStorageFtwWorkingBase));
> + ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) +
> + PcdGet32(PcdFlashNvStorageFtwWorkingSize) ==
> + PcdGet32(PcdFlashNvStorageFtwSpareBase));
> +
> + // Check if the size of the area is at least one block size
> + ASSERT((PcdGet32(PcdFlashNvStorageVariableSize) > 0) &&
> + (PcdGet32(PcdFlashNvStorageVariableSize) / BlockSize > 0));
> + ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingSize) > 0) &&
> + (PcdGet32(PcdFlashNvStorageFtwWorkingSize) / BlockSize > 0));
> + ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareSize) > 0) &&
> + (PcdGet32(PcdFlashNvStorageFtwSpareSize) / BlockSize > 0));
> +
> + // Ensure the Variable areas are aligned on block size boundaries
> + ASSERT((PcdGet32(PcdFlashNvStorageVariableBase) % BlockSize) == 0);
> + ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingBase) % BlockSize) == 0);
> + ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareBase) % BlockSize) == 0);
Space after ASSERT above?
> +
> + //
> + // EFI_FIRMWARE_VOLUME_HEADER
> + //
> + FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers;
> + CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
> + FirmwareVolumeHeader->FvLength =
> + PcdGet32(PcdFlashNvStorageVariableSize) +
> + PcdGet32(PcdFlashNvStorageFtwWorkingSize) +
> + PcdGet32(PcdFlashNvStorageFtwSpareSize);
Missing space after PcdGet32 (many, above - some, below).
That 4-space indentation does not look accurate.
> + FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;
> + FirmwareVolumeHeader->Attributes = EFI_FVB2_READ_ENABLED_CAP |
> + EFI_FVB2_READ_STATUS |
> + EFI_FVB2_STICKY_WRITE |
> + EFI_FVB2_MEMORY_MAPPED |
> + EFI_FVB2_ERASE_POLARITY |
> + EFI_FVB2_WRITE_STATUS |
> + EFI_FVB2_WRITE_ENABLED_CAP;
> +
> + 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 = (VOID *)((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);
Missing space after PcdGet32.
> +
> + //
> + // 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)
Yikes. Move those "||" to preceding lines, please?
> + )
> + {
> + 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)) {
> + 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);
Missing space after 16.
> + if (Checksum != 0) {
> + DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n",
> + __FUNCTION__, Checksum));
> + return EFI_NOT_FOUND;
> + }
> +
> + VariableStoreHeader = (VOID *)((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_FVB2_READ_ENABLED_CAP | EFI_FVB2_READ_STATUS |
> + EFI_FVB2_STICKY_WRITE | EFI_FVB2_MEMORY_MAPPED |
> + EFI_FVB2_ERASE_POLARITY;
> +
> + // Check if it is write protected
> + if (!Instance->Media.ReadOnly) {
> + FlashFvbAttributes |= EFI_FVB2_WRITE_STATUS | EFI_FVB2_WRITE_ENABLED_CAP;
> + }
> +
> + *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 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.
> +
> + @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 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);
Space after "_THIS".
> +
> + DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n",
> + Instance->RegionBaseAddress));
> +
> + ASSERT(Address != NULL);
Space missing.
> +
> + *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 EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
> +
> + @param Lba Indicates the block whose size to return
> +
> + @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 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));
> +
> + if (!Instance->Initialized && Instance->Initialize) {
> + Instance->Initialize(Instance);
> + }
> +
> + 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 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 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.
> +
> + @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) {
> + // 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, UINT32);
> +
> + // All blocks must be within range
> + DEBUG ((DEBUG_BLKIO,
> + "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%d - 1 ) > LastBlock=%ld.\n",
> + Instance->StartLba + StartingLba, 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, UINT32);
> +
> + // 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
> +**/
> +STATIC
> +VOID
> +EFIAPI
> +FvbVirtualNotifyEvent (
> + IN EFI_EVENT Event,
> + IN VOID *Context
> + )
> +{
> + EfiConvertPointer (0x0, (VOID**)&mFlashNvStorageVariableBase);
> + return;
> +}
> +
> +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"));
> +
> + Instance->Initialized = TRUE;
> + mFlashNvStorageVariableBase = FixedPcdGet32 (PcdFlashNvStorageVariableBase);
> +
> + // Set the index of the first LBA for the FVB
> + Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) -
> + 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;
Missing spaces and shaky indentation.
/
Leif
> +
> + 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;
> + }
> + }
> +
> + //
> + // Declare the Non-Volatile storage as EFI_MEMORY_RUNTIME
> + //
> + RuntimeMmioRegionSize = Instance->Size;
> +
> + Status = gDS->AddMemorySpace (
> + EfiGcdMemoryTypeMemoryMappedIo,
> + Instance->RegionBaseAddress, RuntimeMmioRegionSize,
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
> + );
> + ASSERT_EFI_ERROR (Status);
> +
> + Status = gDS->SetMemorySpaceAttributes (
> + Instance->RegionBaseAddress, RuntimeMmioRegionSize,
> + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME);
> + 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;
> +}
> --
> 2.11.0
>
next prev parent reply other threads:[~2017-09-11 19:10 UTC|newest]
Thread overview: 33+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-09-08 18:23 [PATCH edk2-platforms 00/14] add support for Socionext Synquacer EVB Ard Biesheuvel
2017-09-08 18:23 ` [PATCH edk2-platforms 01/14] Silicon/Synquacer: add package with platform headers Ard Biesheuvel
2017-09-11 13:31 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 02/14] Silicon/Synquacer: add MemoryInitPeiLib implementation Ard Biesheuvel
2017-09-11 13:36 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 03/14] Platform: add support for Socionext Synquacer eval board Ard Biesheuvel
2017-09-11 13:54 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 04/14] Silicon/Synquacer: implement PciSegmentLib to support dual RCs Ard Biesheuvel
2017-09-11 14:03 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 05/14] Silicon/Synquacer: implement PciHostBridgeLib support Ard Biesheuvel
2017-09-11 14:22 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 06/14] Silicon/Synquacer: implement EFI_CPU_IO2_PROTOCOL Ard Biesheuvel
2017-09-11 14:45 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 07/14] Platform/SynquacerEvalBoard: add PCI support Ard Biesheuvel
2017-09-11 14:48 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 08/14] Silicon/Socionext: add driver for NETSEC network controller Ard Biesheuvel
2017-09-11 16:12 ` Leif Lindholm
2017-10-28 13:06 ` Ard Biesheuvel
2017-10-28 21:25 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 09/14] Platform/SynquacerEvalBoard: add NETSEC driver Ard Biesheuvel
2017-09-11 16:23 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 10/14] Silicon/Synquacer: add ACPI support Ard Biesheuvel
2017-09-11 16:33 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 11/14] Silicon/Synquacer: add device tree support for eval board Ard Biesheuvel
2017-09-11 16:37 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 12/14] Silicon/Synquacer: add NorFlashPlatformLib implementation Ard Biesheuvel
2017-09-11 16:38 ` Leif Lindholm
2017-09-08 18:23 ` [PATCH edk2-platforms 13/14] Silicon/Socionext: add driver for SPI NOR flash Ard Biesheuvel
2017-09-11 19:13 ` Leif Lindholm [this message]
[not found] ` <e55ff6c595f74189bd53787f3b6b2283@SOC-EX03V.e01.socionext.com>
2017-09-12 8:38 ` Leif Lindholm
2017-09-12 10:48 ` methavanitpong.pipat
2017-09-08 18:23 ` [PATCH edk2-platforms 14/14] Platform/Synquacer: incorporate NOR flash and variable drivers Ard Biesheuvel
2017-09-11 19:13 ` Leif Lindholm
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=20170911191301.wcvgqyylckmbiswl@bivouac.eciton.net \
--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