[edk2,edk2-platforms,13/14] Silicon/Socionext: add driver for SPI NOR flash

Message ID 20170908182315.9591-14-ard.biesheuvel@linaro.org
State New
Headers show
Series
  • add support for Socionext Synquacer EVB
Related show

Commit Message

Ard Biesheuvel Sept. 8, 2017, 6:23 p.m.
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(+)

-- 
2.11.0

_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel

Comments

Leif Lindholm Sept. 11, 2017, 7:13 p.m. | #1
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

> 

_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel
Leif Lindholm Sept. 12, 2017, 8:38 a.m. | #2
On Tue, Sep 12, 2017 at 01:41:34AM +0000, methavanitpong.pipat@socionext.com wrote:
> > -----Original Message-----
> > From: Leif Lindholm [mailto:leif.lindholm@linaro.org]
> > Sent: Tuesday, September 12, 2017 4:13 AM
> > To: Ard Biesheuvel <ard.biesheuvel@linaro.org>
> > Cc: edk2-devel@lists.01.org; Methavanitpong, Pipat/メタワニットポン ピパット
> > <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
> > 
> > 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>

> [Methavanitpong, Pipat/メタワニットポン ピパット] 
> Hi Leif, 
> 
> 1. Hex magic
> 
> There are 2 hex magic in this driver
> 
>   1. FIP006 command sequencer decode command
> 
>      FIP006 in command sequencer mode detects accesses to its memory region. 
>      An access to this region is translated into commands according to 
>      FIP006_REG_CS_RD and FIP006_REG_CS_WR for read and write accordingly. 
> 
>      A single access can be translated up to 8 1-byte commands, as the 
>      registers have 8 slots each. Each command is transmitted consecutively
>      starting from their base addresses. 
> 
>      Each slot in the registers are decoded as
> 
>      1. Immediate value - CSDC(imm, ..., ..., DEC=0)
>      2. Addr[7:0] - CSDC(0x00, ..., ..., DEC=1)
>      3. Addr[15:8] - CSDC(0x01, ..., ..., DEC=1)
>      4. Addr[23:16] - CSDC(0x02, ..., ..., DEC=1)
>      5. Addr[31:24] - CSDC(0x03, ..., ..., DEC=1)
>      6. HiZ for 1 byte - CSDC(0x04, ..., ..., DEC=1)
>      7. Upper 4-bit immediate value + 4-bit HiZ - CSDC((imm << 4) | 0x05, ..., ..., DEC=1)
>      8. Command termination - CSDC(0x07, ..., ..., DEC=1)
> 
>   2. Micron N25Q flash command
> 
>      In order to send a command to a flash device, FIP006's FIP006_REG_CS_RD 
>      and FIP006_REG_CS_WR must be set properly. NorFlashSetHostCommand() 
>      sets these registers according to an instance's command definition table. 
> 
>      For example; NorFlashSetHostCommand (Instance, 0x13) corresponds to a 
>      read access with 4-byte addressing read serial nor flash command (0x13). 
>      The result FIP006_REG_CS_RD is the following:
> 
>          FIP006_REG_CS_RD[0] = CSDC(0x13, 0, 1-bit lane, DEC=0)
>          FIP006_REG_CS_RD[1] = CSDC(0x03, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[2] = CSDC(0x02, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[3] = CSDC(0x01, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[4] = CSDC(0x00, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[5] = CSDC(0x07, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[6] = CSDC(0x07, 0, 1-bit lane, DEC=1)
>          FIP006_REG_CS_RD[7] = CSDC(0x07, 0, 1-bit lane, DEC=1)

Thank you for the explanation.
However, the code needs to be be readable by someone who does not have
the instruction set for each given component fresh in their mind.

That means that direct numeral expressions should be avoided wherever
they are not mathematically obvious (and where you consider them
obvious, consider whether everyone else would agree without already
knowing what the code is intended to do).

They should be replaced by #defines or enums as appropriate.

> 2. Bit field declaration
> 
> About the bitfield struct you mentioned in "Fip006Reg.h", 
> What should be a good way to declare it?

The problem with bitfields is that they are not very well defined in
the C language, and hence do not tend to be very portable.

Tedious as it may seem, #defines with shifts and masks are usually the
way to go.

Regards,

Leif
methavanitpong.pipat@socionext.com Sept. 12, 2017, 10:48 a.m. | #3
> -----Original Message-----

> From: Leif Lindholm [mailto:leif.lindholm@linaro.org]

> Sent: Tuesday, September 12, 2017 5:39 PM

> To: Methavanitpong, Pipat/メタワニットポン ピパット

> <methavanitpong.pipat@socionext.com>

> Cc: edk2-devel@lists.01.org; masahisa.kojima@linaro.org;

> masami.hiramatsu@linaro.org; ard.biesheuvel@linaro.org

> Subject: Re: [PATCH edk2-platforms 13/14] Silicon/Socionext: add driver

> for SPI NOR flash

> 

> On Tue, Sep 12, 2017 at 01:41:34AM +0000,

> methavanitpong.pipat@socionext.com wrote:

> > > -----Original Message-----

> > > From: Leif Lindholm [mailto:leif.lindholm@linaro.org]

> > > Sent: Tuesday, September 12, 2017 4:13 AM

> > > To: Ard Biesheuvel <ard.biesheuvel@linaro.org>

> > > Cc: edk2-devel@lists.01.org; Methavanitpong, Pipat/メタワニットポン ピ

> パット

> > > <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

> > >

> > > 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>

> 

> > [Methavanitpong, Pipat/メタワニットポン ピパット]

> > Hi Leif,

> >

> > 1. Hex magic

> >

> > There are 2 hex magic in this driver

> >

> >   1. FIP006 command sequencer decode command

> >

> >      FIP006 in command sequencer mode detects accesses to its memory

> region.

> >      An access to this region is translated into commands according to

> >      FIP006_REG_CS_RD and FIP006_REG_CS_WR for read and write

> accordingly.

> >

> >      A single access can be translated up to 8 1-byte commands, as the

> >      registers have 8 slots each. Each command is transmitted

> consecutively

> >      starting from their base addresses.

> >

> >      Each slot in the registers are decoded as

> >

> >      1. Immediate value - CSDC(imm, ..., ..., DEC=0)

> >      2. Addr[7:0] - CSDC(0x00, ..., ..., DEC=1)

> >      3. Addr[15:8] - CSDC(0x01, ..., ..., DEC=1)

> >      4. Addr[23:16] - CSDC(0x02, ..., ..., DEC=1)

> >      5. Addr[31:24] - CSDC(0x03, ..., ..., DEC=1)

> >      6. HiZ for 1 byte - CSDC(0x04, ..., ..., DEC=1)

> >      7. Upper 4-bit immediate value + 4-bit HiZ - CSDC((imm << 4) |

> 0x05, ..., ..., DEC=1)

> >      8. Command termination - CSDC(0x07, ..., ..., DEC=1)

> >

> >   2. Micron N25Q flash command

> >

> >      In order to send a command to a flash device, FIP006's

> FIP006_REG_CS_RD

> >      and FIP006_REG_CS_WR must be set properly. NorFlashSetHostCommand()

> >      sets these registers according to an instance's command definition

> table.

> >

> >      For example; NorFlashSetHostCommand (Instance, 0x13) corresponds to

> a

> >      read access with 4-byte addressing read serial nor flash command

> (0x13).

> >      The result FIP006_REG_CS_RD is the following:

> >

> >          FIP006_REG_CS_RD[0] = CSDC(0x13, 0, 1-bit lane, DEC=0)

> >          FIP006_REG_CS_RD[1] = CSDC(0x03, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[2] = CSDC(0x02, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[3] = CSDC(0x01, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[4] = CSDC(0x00, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[5] = CSDC(0x07, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[6] = CSDC(0x07, 0, 1-bit lane, DEC=1)

> >          FIP006_REG_CS_RD[7] = CSDC(0x07, 0, 1-bit lane, DEC=1)

> 

> Thank you for the explanation.

> However, the code needs to be be readable by someone who does not have the

> instruction set for each given component fresh in their mind.

> 

> That means that direct numeral expressions should be avoided wherever they

> are not mathematically obvious (and where you consider them obvious,

> consider whether everyone else would agree without already knowing what

> the code is intended to do).

> 

> They should be replaced by #defines or enums as appropriate.

> 

> > 2. Bit field declaration

> >

> > About the bitfield struct you mentioned in "Fip006Reg.h", What should

> > be a good way to declare it?

> 

> The problem with bitfields is that they are not very well defined in the C

> language, and hence do not tend to be very portable.

> 

> Tedious as it may seem, #defines with shifts and masks are usually the way

> to go.


Thank you for your comment, Leif. 
I will see what I can do with Ard. 

> 

> Regards,

> 

> Leif


--
Pipat Methavanitpong
Software Developer, S-Project 3
Socionext Inc.

Patch

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
+  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
+  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;
+
+#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>
+
+  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);
+
+  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 ) {
+    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>
+
+  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>
+
+#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++) {
+    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));
+
+  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);
+  }
+
+  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);
+  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);
+  return EFI_SUCCESS;
+}
+
+// TODO: implement lock checking
+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;
+
+  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;
+    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;
+
+  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;
+    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);
+  *(UINT16*) Instance->RegionBaseAddress = SwapBytes16 (Sector);
+  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);
+  *(UINT32*) WordAddress = WriteData;
+  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.
+    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) {
+    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);
+  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;
+
+  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.
+      if ((CurOffset & 0x3) == 0) {
+        if (BytesToWrite >= 4) {
+          // Is the destination still in 'erased' state?
+          if (~Tmp != 0) {
+            // Check to see if we are only changing bits to zero.
+            if ((Tmp ^ TmpBuf) & TmpBuf) {
+              DoErase = TRUE;
+              break;
+            }
+          }
+          // Write this word to NOR
+          WordToWrite = TmpBuf;
+          CurOffset += sizeof(TmpBuf);
+          BytesToWrite -= sizeof(TmpBuf);
+        } else {
+          // BytesToWrite < 4. Do small writes and left-overs
+          Mask = ~((~0) << (BytesToWrite * 8));
+          // Mask out the bytes we want.
+          TmpBuf &= Mask;
+          // Is the destination still in 'erased' state?
+          if ((Tmp & Mask) != Mask) {
+            // Check to see if we are only changing bits to zero.
+            if ((Tmp ^ TmpBuf) & TmpBuf) {
+              DoErase = TRUE;
+              break;
+            }
+          }
+          // Merge old and new data. Write merged word to NOR
+          WordToWrite = (Tmp & ~Mask) | TmpBuf;
+          CurOffset += BytesToWrite;
+          BytesToWrite = 0;
+        }
+      } else {
+        // Do multiple words, but starting unaligned.
+        if (BytesToWrite > (4 - (CurOffset & 0x3))) {
+          Mask = ((~0) << ((CurOffset & 0x3) * 8));
+          // Mask out the bytes we want.
+          TmpBuf &= Mask;
+          // Is the destination still in 'erased' state?
+          if ((Tmp & Mask) != Mask) {
+            // Check to see if we are only changing bits to zero.
+            if ((Tmp ^ TmpBuf) & TmpBuf) {
+              DoErase = TRUE;
+              break;
+            }
+          }
+          // Merge old and new data. Write merged word to NOR
+          WordToWrite = (Tmp & ~Mask) | TmpBuf;
+          BytesToWrite -= (4 - (CurOffset & 0x3));
+          CurOffset += (4 - (CurOffset & 0x3));
+        } else {
+          // Unaligned and fits in one word.
+          Mask = (~((~0) << (BytesToWrite * 8))) << ((CurOffset & 0x3) * 8);
+          // Mask out the bytes we want.
+          TmpBuf = (TmpBuf << ((CurOffset & 0x3) * 8)) & Mask;
+          // Is the destination still in 'erased' state?
+          if ((Tmp & Mask) != Mask) {
+            // Check to see if we are only changing bits to zero.
+            if ((Tmp ^ TmpBuf) & TmpBuf) {
+              DoErase = TRUE;
+              break;
+            }
+          }
+          // Merge old and new data. Write merged word to NOR
+          WordToWrite = (Tmp & ~Mask) | TmpBuf;
+          CurOffset += BytesToWrite;
+          BytesToWrite = 0;
+        }
+      }
+
+      //
+      // Write the word to NOR.
+      //
+
+      BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba,
+        BlockSize);
+      if (BlockAddress != PrevBlockAddress) {
+        TempStatus = NorFlashUnlockSingleBlockIfNecessary (Instance,
+                       BlockAddress);
+        if (EFI_ERROR (TempStatus)) {
+          return EFI_DEVICE_ERROR;
+        }
+        PrevBlockAddress = BlockAddress;
+      }
+      TempStatus = NorFlashWriteSingleWord (Instance, WordAddr, WordToWrite);
+      if (EFI_ERROR (TempStatus)) {
+        return EFI_DEVICE_ERROR;
+      }
+    }
+    // Exit if we got here and could write all the data. Otherwise do the
+    // Erase-Write cycle.
+    if (!DoErase) {
+      return EFI_SUCCESS;
+    }
+  }
+
+  // Check we did get some memory. Buffer is BlockSize.
+  if (Instance->ShadowBuffer == NULL) {
+    DEBUG ((DEBUG_ERROR, "FvbWrite: ERROR - Buffer not ready\n"));
+    return EFI_DEVICE_ERROR;
+  }
+
+  // Read NOR Flash data into shadow buffer
+  TempStatus = NorFlashReadBlocks (Instance, Lba, BlockSize,
+                 Instance->ShadowBuffer);
+  if (EFI_ERROR (TempStatus)) {
+    // Return one of the pre-approved error statuses
+    return EFI_DEVICE_ERROR;
+  }
+
+  // Put the data at the appropriate location inside the buffer area
+  CopyMem ((VOID*)((UINTN)Instance->ShadowBuffer + Offset), Buffer, *NumBytes);
+
+  // Write the modified buffer back to the NorFlash
+  TempStatus = NorFlashWriteBlocks (Instance, Lba, BlockSize,
+                 Instance->ShadowBuffer);
+  if (EFI_ERROR (TempStatus)) {
+    // Return one of the pre-approved error statuses
+    return EFI_DEVICE_ERROR;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/*
+  Although DiskIoDxe will automatically install the DiskIO protocol whenever
+  we install the BlockIO protocol, its implementation is sub-optimal as it reads
+  and writes entire blocks using the BlockIO protocol. In fact we can access
+  NOR flash with a finer granularity than that, so we can improve performance
+  by directly producing the DiskIO protocol.
+*/
+
+/**
+  Read BufferSize bytes from Offset into Buffer.
+
+  @param  This                  Protocol instance pointer.
+  @param  MediaId               Id of the media, changes every time the media is
+                                replaced.
+  @param  Offset                The starting byte offset to read from
+  @param  BufferSize            Size of Buffer
+  @param  Buffer                Buffer containing read data
+
+  @retval EFI_SUCCESS           The data was read correctly from the device.
+  @retval EFI_DEVICE_ERROR      The device reported an error while performing
+                                the read.
+  @retval EFI_NO_MEDIA          There is no media in the device.
+  @retval EFI_MEDIA_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);
+
+  RemainingBytes = BufferSize;
+
+  // Write either all the remaining bytes, or the number of bytes that bring
+  // us up to a block boundary, whichever is less.
+  // (DiskOffset | (BlockSize - 1)) + 1) rounds DiskOffset up to the next
+  // block boundary (even if it is already on one).
+  WriteSize = MIN (RemainingBytes,
+                   ((DiskOffset | (BlockSize - 1)) + 1) - DiskOffset);
+
+  do {
+    if (WriteSize == BlockSize) {
+      // Write a full block
+      Status = NorFlashWriteFullBlock (Instance, Lba, Buffer,
+                 BlockSize / sizeof (UINT32));
+    } else {
+      // Write a partial block
+      Status = NorFlashWriteSingleBlock (Instance, Lba, BlockOffset, &WriteSize,
+                 Buffer);
+    }
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    // Now continue writing either all the remaining bytes or single blocks.
+    RemainingBytes -= WriteSize;
+    Buffer = (UINT8 *) Buffer + WriteSize;
+    Lba++;
+    BlockOffset = 0;
+    WriteSize = MIN (RemainingBytes, BlockSize);
+  } while (RemainingBytes);
+
+  return Status;
+}
+
+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)
+        }
+      },
+      { 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,
+                                      &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;
+  Instance->OffsetLba = (NorFlashRegionBase - NorFlashDeviceBase) / BlockSize;
+
+  CopyGuid (&Instance->DevicePath.Vendor.Guid, NorFlashGuid);
+
+  Instance->CmdTable = CommandTable;
+  Instance->CmdTableSize = CommandTableSize;
+
+  Instance->ShadowBuffer = AllocateRuntimePool (BlockSize);;
+  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);
+  CsCfg.Reg.MBM = CS_CFG_MBM_SINGLE;
+  CsCfg.Reg.SRAM = CS_CFG_SRAM_RW;
+  NOR_FLASH_SET_HOST_REG(Instance, CS_CFG, CsCfg);
+  NorFlashSetHostCommand (Instance, 0x13);
+  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>
+
+#include "Fip006Reg.h"
+
+#define NOR_FLASH_ERASE_RETRY                     10
+
+#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + (UINTN)((Lba) * LbaSize) )
+
+#define NOR_FLASH_READ_BYTE(Instance, Addr) \
+  (((UINT8*) Instance->RegionBaseAddress + Addr)[0])
+
+#define NOR_FLASH_WRITE_BYTE(Instance, Addr, Src) \
+  do { \
+    ((UINT8*) Instance->RegionBaseAddress + Addr)[0] = Src; \
+  } while (0)
+
+#define NOR_FLASH_GET_HOST_REG(Instance, Reg, Dst) \
+  do { \
+    Dst.Raw = MmioRead32(Instance->HostRegisterBaseAddress + FIP006_REG_##Reg); \
+  } while (0)
+
+#define NOR_FLASH_SET_HOST_REG(Instance, Reg, Src) \
+  do { \
+    MmioWrite32 (Instance->HostRegisterBaseAddress + FIP006_REG_##Reg, Src.Raw); \
+  } 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)
+
+#define CSDC(Data, Cont, Trp, Dec) \
+  ((Data << 8) | (Cont << 3) | (Trp << 1) | 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>
+
+#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);
+
+  //
+  // EFI_FIRMWARE_VOLUME_HEADER
+  //
+  FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers;
+  CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
+  FirmwareVolumeHeader->FvLength =
+      PcdGet32(PcdFlashNvStorageVariableSize) +
+      PcdGet32(PcdFlashNvStorageFtwWorkingSize) +
+      PcdGet32(PcdFlashNvStorageFtwSpareSize);
+  FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;
+  FirmwareVolumeHeader->Attributes = EFI_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);
+
+  //
+  // Verify the header revision, header signature, length
+  // Length of FvBlock cannot be 2**64-1
+  // HeaderLength cannot be an odd number
+  //
+  if (   (FwVolHeader->Revision  != EFI_FVH_REVISION)
+      || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)
+      || (FwVolHeader->FvLength  != FvLength)
+      )
+  {
+    DEBUG ((DEBUG_INFO, "%a: No Firmware Volume header present\n",
+      __FUNCTION__));
+    return EFI_NOT_FOUND;
+  }
+
+  // Check the Firmware Volume Guid
+  if (!CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid)) {
+    DEBUG ((DEBUG_INFO, "%a: Firmware Volume Guid non-compatible\n",
+      __FUNCTION__));
+    return EFI_NOT_FOUND;
+  }
+
+  // Verify the header checksum
+  Checksum = CalculateSum16((UINT16*)FwVolHeader, FwVolHeader->HeaderLength);
+  if (Checksum != 0) {
+    DEBUG ((DEBUG_INFO, "%a: FV checksum is invalid (Checksum:0x%X)\n",
+      __FUNCTION__, Checksum));
+    return EFI_NOT_FOUND;
+  }
+
+  VariableStoreHeader = (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);
+
+  DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n",
+    Instance->RegionBaseAddress));
+
+  ASSERT(Address != NULL);
+
+  *Address = mFlashNvStorageVariableBase;
+  return EFI_SUCCESS;
+}
+
+/**
+ The GetBlockSize() function retrieves the size of the requested
+ block. It also returns the number of additional blocks with
+ the identical size. The GetBlockSize() function is used to
+ retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
+
+
+ @param This                     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;
+
+    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;
+}