[PATCH edk2-platforms v2 2/4] Platform/NXP : Add Support for NOR flash Library

[Vabhav <vabhav.sharma@nxp.com>]

Adding support for NOR flash library(NorFlashLib)
to provide functions which will be used by NOR flash
Driver.

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Vabhav <vabhav.sharma@nxp.com>
---
 Platform/NXP/Include/Library/NorFlashLib.h        |  67 +++
 Platform/NXP/Library/NorFlashLib/CfiCommand.h     |  99 ++++
 Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.c | 184 ++++++
 Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.h |  54 ++
 Platform/NXP/Library/NorFlashLib/IfcNorFlashLib.c |  52 ++
 Platform/NXP/Library/NorFlashLib/NorFlashLib.c    | 658 ++++++++++++++++++++++
 Platform/NXP/Library/NorFlashLib/NorFlashLib.inf  |  42 ++
 7 files changed, 1156 insertions(+)
 create mode 100644 Platform/NXP/Include/Library/NorFlashLib.h
 create mode 100644 Platform/NXP/Library/NorFlashLib/CfiCommand.h
 create mode 100644 Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.c
 create mode 100644 Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.h
 create mode 100644 Platform/NXP/Library/NorFlashLib/IfcNorFlashLib.c
 create mode 100644 Platform/NXP/Library/NorFlashLib/NorFlashLib.c
 create mode 100644 Platform/NXP/Library/NorFlashLib/NorFlashLib.inf

diff --git a/Platform/NXP/Include/Library/NorFlashLib.h b/Platform/NXP/Include/Library/NorFlashLib.h
new file mode 100644
index 0000000..8eb0f82
--- /dev/null
+++ b/Platform/NXP/Include/Library/NorFlashLib.h
@@ -0,0 +1,67 @@
+/** @file
+
+ Copyright (c) 2011-2012, ARM Ltd. All rights reserved.
+ Copyright (c) 2016, Freescale Semiconductor. All rights reserved.
+ Copyright 2017 NXP
+
+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_LIB_H_
+#define _NOR_FLASH_LIB_H_
+
+#include <Library/Ifc.h>
+
+typedef struct {
+  UINTN DeviceBaseAddress;   // Start address of the Device Base Address (DBA)
+  UINTN RegionBaseAddress;   // Start address of one single region
+  UINTN Size;
+  UINTN BlockSize;
+  UINTN MultiByteWordCount;  // Maximum Word count that can be written to Nor Flash in multi byte write
+  UINTN WordWriteTimeOut;    // single byte/word timeout usec
+  UINTN BufferWriteTimeOut;  // buffer write timeout usec
+  UINTN BlockEraseTimeOut;   // block erase timeout usec
+  UINTN ChipEraseTimeOut;    // chip erase timeout usec
+} NorFlashDescription;
+
+EFI_STATUS
+NorFlashPlatformGetDevices (
+  OUT NorFlashDescription **NorFlashDevices,
+  OUT UINT32              *Count
+  );
+
+EFI_STATUS
+NorFlashPlatformFlashGetAttributes (
+  OUT NorFlashDescription *NorFlashDevices,
+  IN  UINT32              Count
+  );
+
+typedef struct {
+  UINT8     ChipSelect;
+  IFC_REGS* IfcRegs;
+} NorFlashInfo;
+
+VOID
+GetIfcNorFlashInfo (
+  IN NorFlashInfo *NorFlashInfo
+  );
+
+VOID
+GetIfcNorFlashTimings (
+  IN IfcTimings * NorIfcTimings
+  );
+
+typedef UINT16 FLASH_DATA;
+
+FLASH_DATA IfcNorFlashData (FLASH_DATA Val);
+
+VOID IfcNorWrite32 (VOID *a, UINT32 v);
+
+#endif /* _NOR_FLASH_LIB_H_ */
diff --git a/Platform/NXP/Library/NorFlashLib/CfiCommand.h b/Platform/NXP/Library/NorFlashLib/CfiCommand.h
new file mode 100644
index 0000000..5e755be
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/CfiCommand.h
@@ -0,0 +1,99 @@
+/** @CfiCommand.h
+
+  Copyright 2017 NXP
+
+  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 __CFI_COMMAND_H__
+#define __CFI_COMMAND_H__
+
+// CFI Data "QRY"
+#define CFI_QRY_Q                                0x51
+#define CFI_QRY_R                                0x52
+#define CFI_QRY_Y                                0x59
+#define CFI_QRY                                  0x515259
+
+#define ENTER_CFI_QUERY_MODE_ADDR   0x0055
+#define ENTER_CFI_QUERY_MODE_CMD    0x0098
+
+#define CFI_QUERY_UNIQUE_QRY_STRING 0x10
+
+// Offsets for CFI queries
+#define CFI_QUERY_TYP_TIMEOUT_WORD_WRITE        0x1F
+#define CFI_QUERY_TYP_TIMEOUT_MAX_BUFFER_WRITE  0x20
+#define CFI_QUERY_TYP_TIMEOUT_BLOCK_ERASE       0x21
+#define CFI_QUERY_TYP_TIMEOUT_CHIP_ERASE        0x22
+#define CFI_QUERY_MAX_TIMEOUT_WORD_WRITE        0x23
+#define CFI_QUERY_MAX_TIMEOUT_MAX_BUFFER_WRITE  0x24
+#define CFI_QUERY_MAX_TIMEOUT_BLOCK_ERASE       0x25
+#define CFI_QUERY_MAX_TIMEOUT_CHIP_ERASE        0x26
+#define CFI_QUERY_DEVICE_SIZE                   0x27
+#define CFI_QUERY_MAX_NUM_BYTES_WRITE           0x2A
+#define CFI_QUERY_BLOCK_SIZE                    0x2F
+
+// Unlock Address
+#define CMD_UNLOCK_1_ADDR           0x555
+#define CMD_UNLOCK_2_ADDR           0x2AA
+
+// RESET Command
+#define CMD_RESET_FIRST              0xAA
+#define CMD_RESET_SECOND             0x55
+#define CMD_RESET                    0xF0
+
+// READ Command
+
+// Manufacturer ID
+#define CMD_READ_M_ID_FIRST          0xAA
+#define CMD_READ_M_ID_SECOND         0x55
+#define CMD_READ_M_ID_THIRD          0x90
+#define CMD_READ_M_ID_FOURTH         0x01
+
+// Device ID
+#define CMD_READ_D_ID_FIRST          0xAA
+#define CMD_READ_D_ID_SECOND         0x55
+#define CMD_READ_D_ID_THIRD          0x90
+#define CMD_READ_D_ID_FOURTH         0x7E
+#define CMD_READ_D_ID_FIFTH          0x13
+#define CMD_READ_D_ID_SIXTH          0x00
+
+// WRITE Commands
+
+// PROGRAM Commands
+#define CMD_PROGRAM_FIRST            0xAA
+#define CMD_PROGRAM_SECOND           0x55
+#define CMD_PROGRAM_THIRD            0xA0
+
+// Write Buffer Commands
+#define CMD_WRITE_TO_BUFFER_FIRST    0xAA
+#define CMD_WRITE_TO_BUFFER_SECOND   0x55
+#define CMD_WRITE_TO_BUFFER_THIRD    0x25
+#define CMD_WRITE_TO_BUFFER_CONFIRM  0x29
+
+// ERASE Commands
+
+// UNLOCK COMMANDS FOR ERASE
+#define CMD_ERASE_FIRST              0xAA
+#define CMD_ERASE_SECOND             0x55
+#define CMD_ERASE_THIRD              0x80
+#define CMD_ERASE_FOURTH             0xAA
+#define CMD_ERASE_FIFTH              0x55
+
+// Chip Erase Commands
+#define CMD_CHIP_ERASE_SIXTH         0x10
+
+// Sector Erase Commands
+#define CMD_SECTOR_ERASE_SIXTH       0x30
+
+// SUSPEND Commands
+#define CMD_PROGRAM_OR_ERASE_SUSPEND 0xB0
+#define CMD_PROGRAM_OR_ERASE_RESUME  0x30
+
+#endif /* __CFI_FLASH_H__ */
diff --git a/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.c b/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.c
new file mode 100644
index 0000000..2683cae
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.c
@@ -0,0 +1,184 @@
+/** @CfiNorFlashLib.c
+
+ Copyright (c) 2015, Freescale Semiconductor, Inc. All rights reserved.
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution.  The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+ **/
+
+#include <PiDxe.h>
+#include <Library/ArmLib.h>
+#include <Library/NorFlash.h>
+#include "CfiCommand.h"
+#include "CfiNorFlashLib.h"
+
+VOID
+FlashWrite_Data (
+   FLASH_DATA Val,
+   UINTN Addr
+   )
+{
+  *(volatile FLASH_DATA *)(Addr) = (Val);
+}
+
+VOID
+FlashWrite (
+   FLASH_DATA Val,
+   UINTN Addr
+   )
+{
+  FLASH_DATA ShiftVal;
+  ShiftVal = IfcNorFlashData (Val);
+
+  *(volatile FLASH_DATA *)(Addr) = (ShiftVal);
+}
+
+FLASH_DATA
+FlashReadData (
+  UINTN Addr
+  )
+{
+  FLASH_DATA Val;
+  Val = *(volatile FLASH_DATA *)(Addr);
+
+  return (Val);
+}
+
+FLASH_DATA
+FlashRead (
+  UINTN Addr
+  )
+{
+  FLASH_DATA Val;
+  FLASH_DATA ShiftVal;
+
+  Val = *(volatile FLASH_DATA *)(Addr);
+  ShiftVal = IfcNorFlashData (Val);
+
+  return (ShiftVal);
+}
+
+STATIC
+VOID
+NorFlashReadCfiData (
+  IN  UINTN  DeviceBaseAddress,
+  IN  UINTN  CFI_Offset,
+  IN  UINT32 NumberOfShorts,
+  OUT VOID   *Data
+  )
+{
+  UINT32     Count;
+  FLASH_DATA *TmpData = (FLASH_DATA *)Data;
+
+  for (Count = 0; Count < NumberOfShorts; Count++, TmpData++) {
+      *TmpData = FLASH_READ ((UINTN)((FLASH_DATA*)DeviceBaseAddress + CFI_Offset));
+      CFI_Offset++;
+  }
+}
+
+/*
+  Currently we support only CFI flash devices; Bail-out otherwise
+*/
+EFI_STATUS
+CfiNorFlashFlashGetAttributes (
+  OUT NorFlashDescription *NorFlashDevices,
+  IN UINT32               Index
+  )
+{
+  UINT32                    Count;
+  FLASH_DATA                QryData[3] = {0};
+  FLASH_DATA                BlockSize[2] = {0};
+  UINTN                     DeviceBaseAddress = 0;
+  FLASH_DATA                MaxNumBytes[2] = {0};
+  FLASH_DATA                Size = 0;
+  FLASH_DATA                HighByteMask = 0xFF; // Masks High byte in a UIN16 word
+  FLASH_DATA                HighByteShift = 8; // Bitshifts needed to make a byte High Byte in a UIN16 word
+  FLASH_DATA                Temp1 = 0;
+  FLASH_DATA                Temp2 = 0;
+
+  for (Count = 0; Count < Index; Count++) {
+
+    NorFlashDevices[Count].DeviceBaseAddress = DeviceBaseAddress = PcdGet64 (PcdFlashDeviceBase64);
+
+    // Reset flash first
+    NorFlashPlatformReset (DeviceBaseAddress);
+
+    // Enter the CFI Query Mode
+    SEND_NOR_COMMAND (DeviceBaseAddress, ENTER_CFI_QUERY_MODE_ADDR,
+            ENTER_CFI_QUERY_MODE_CMD);
+
+    ArmDataSynchronizationBarrier ();
+
+    // Query the unique QRY
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_UNIQUE_QRY_STRING,
+            3,
+            &QryData);
+    if (QryData[0] != (FLASH_DATA)CFI_QRY_Q || QryData[1] !=
+            (FLASH_DATA)CFI_QRY_R || QryData[2] != (FLASH_DATA)CFI_QRY_Y ) {
+      DEBUG ((DEBUG_ERROR, "Not a CFI flash (QRY not recvd): "
+                   "Got = 0x%04x, 0x%04x, 0x%04x\n",
+                   QryData[0], QryData[1], QryData[2]));
+        return EFI_DEVICE_ERROR;
+     }
+
+    NorFlashReadCfiData (DeviceBaseAddress, CFI_QUERY_DEVICE_SIZE,
+                            1, &Size);
+    // Refer CFI Specification
+    NorFlashDevices[Count].Size = 1 << Size;
+
+    NorFlashReadCfiData (DeviceBaseAddress, CFI_QUERY_BLOCK_SIZE,
+                            2, &BlockSize);
+    // Refer CFI Specification
+    NorFlashDevices[Count].BlockSize = 256 * ((FLASH_DATA) ((BlockSize[1] <<
+                    HighByteShift) | (BlockSize[0] & HighByteMask)));
+
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_MAX_NUM_BYTES_WRITE, 2, &MaxNumBytes);
+    // Refer CFI Specification
+    /* from CFI query we get the Max. number of BYTE in multi-byte write = 2^N.
+       But our Flash Library is able to read/write in WORD size (2 bytes) which
+       is why we need to CONVERT MAX BYTES TO MAX WORDS by diving it by
+       width of word size */
+    NorFlashDevices[Count].MultiByteWordCount =\
+    (1 << ((FLASH_DATA)((MaxNumBytes[1] << HighByteShift) |
+                        (MaxNumBytes[0] & HighByteMask))))/sizeof(FLASH_DATA);
+
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_TYP_TIMEOUT_WORD_WRITE, 1, &Temp1);
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_MAX_TIMEOUT_WORD_WRITE, 1, &Temp2);
+    NorFlashDevices[Count].WordWriteTimeOut = (1U << Temp1) * (1U << Temp2);
+
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_TYP_TIMEOUT_MAX_BUFFER_WRITE, 1, &Temp1);
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_MAX_TIMEOUT_MAX_BUFFER_WRITE, 1, &Temp2);
+    NorFlashDevices[Count].BufferWriteTimeOut = (1U << Temp1) * (1U << Temp2);
+
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_TYP_TIMEOUT_BLOCK_ERASE, 1, &Temp1);
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_MAX_TIMEOUT_BLOCK_ERASE, 1, &Temp2);
+    NorFlashDevices[Count].BlockEraseTimeOut =
+            (1U << Temp1) * (1U << Temp2) * 1000;
+
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_TYP_TIMEOUT_CHIP_ERASE, 1, &Temp1);
+    NorFlashReadCfiData (DeviceBaseAddress,
+            CFI_QUERY_MAX_TIMEOUT_CHIP_ERASE, 1, &Temp2);
+    NorFlashDevices[Count].ChipEraseTimeOut =
+            (1U << Temp1) * (1U << Temp2) * 1000;
+
+    // Put device back into Read Array mode (via Reset)
+    NorFlashPlatformReset (DeviceBaseAddress);
+  }
+
+  return EFI_SUCCESS;
+}
diff --git a/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.h b/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.h
new file mode 100644
index 0000000..0b7a7ad
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/CfiNorFlashLib.h
@@ -0,0 +1,54 @@
+/** @CfiNorFlashLib.h
+
+  Copyright (c) 2015, Freescale Semiconductor, Inc. All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __CFI_NOR_FLASH_LIB_H__
+#define __CFI_NOR_FLASH_LIB_H__
+
+#include <Library/DebugLib.h>
+#include <Library/NorFlashLib.h>
+
+/*
+ * Values for the width of the port
+ */
+#define FLASH_CFI_8BIT               0x01
+#define FLASH_CFI_16BIT              0x02
+#define FLASH_CFI_32BIT              0x04
+#define FLASH_CFI_64BIT              0x08
+
+#define NOR_FLASH_ERASE_RETRY        10
+
+#define CREATE_BYTE_OFFSET(OffsetAddr)           ((sizeof (FLASH_DATA)) * (OffsetAddr))
+#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr)  ((BaseAddr) + (OffsetAddr))
+#define FLASH_READ(Addr)                         FlashRead ((Addr))
+#define FLASH_WRITE(Addr, Val)                   FlashWrite ((Val), (Addr))
+#define FLASH_READ_DATA(Addr)                    FlashReadData ((Addr))
+#define FLASH_WRITE_DATA(Addr, Val)              FlashWrite_Data ((Val), (Addr))
+
+#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd)    FLASH_WRITE (CREATE_NOR_ADDRESS (BaseAddr,CREATE_BYTE_OFFSET(Offset)), (Cmd))
+
+#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)  ( BaseAddr + (UINTN)((Lba) * LbaSize) )
+
+VOID FlashWrite (FLASH_DATA Val, UINTN Addr);
+FLASH_DATA FlashRead (UINTN Addr);
+
+VOID FlashWrite_Data (FLASH_DATA Val, UINTN Addr);
+FLASH_DATA FlashReadData (UINTN Addr);
+
+EFI_STATUS
+CfiNorFlashFlashGetAttributes (
+  OUT NorFlashDescription *NorFlashDevices,
+  IN UINT32               Index
+  );
+
+#endif /* __CFI_NOR_FLASH_LIB_H__ */
diff --git a/Platform/NXP/Library/NorFlashLib/IfcNorFlashLib.c b/Platform/NXP/Library/NorFlashLib/IfcNorFlashLib.c
new file mode 100644
index 0000000..f87ebc3
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/IfcNorFlashLib.c
@@ -0,0 +1,52 @@
+/** @IfcNorLib.c
+
+ Copyright (c) 2017 NXP
+
+ 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/NorFlashLib.h>
+
+/*
+  Initialise Integrated flash controller(IFC) NOR flash
+*/
+VOID
+IfcNorInit (
+  VOID
+  )
+{
+  UINT32 NorCs;
+  NorFlashInfo NorFlashInfo;
+  IfcTimings NorIfcTimings;
+
+  GetIfcNorFlashInfo (&NorFlashInfo);
+  NorCs = NorFlashInfo.ChipSelect;
+
+  // Get Nor Flash Timings
+  GetIfcNorFlashTimings (&NorIfcTimings);
+
+  // Tune IFC Nor Flash Timings
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->CsprCs[NorCs].CsprExt,
+          NorIfcTimings.CsprExt);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->FtimCs[NorCs].Ftim[IFC_FTIM0],
+          NorIfcTimings.Ftim[0]);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->FtimCs[NorCs].Ftim[IFC_FTIM1],
+          NorIfcTimings.Ftim[1]);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->FtimCs[NorCs].Ftim[IFC_FTIM2],
+          NorIfcTimings.Ftim[2]);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->FtimCs[NorCs].Ftim[IFC_FTIM3],
+          NorIfcTimings.Ftim[3]);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->CsprCs[NorCs].Cspr,
+          NorIfcTimings.Cspr);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->AmaskCs[NorCs].Amask,
+          NorIfcTimings.Amask);
+  IfcNorWrite32 (&NorFlashInfo.IfcRegs->CsorCs[NorCs].Csor,
+          NorIfcTimings.Csor);
+}
diff --git a/Platform/NXP/Library/NorFlashLib/NorFlashLib.c b/Platform/NXP/Library/NorFlashLib/NorFlashLib.c
new file mode 100644
index 0000000..e5e469f
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/NorFlashLib.c
@@ -0,0 +1,658 @@
+/** @NorFlashLib.c
+
+  Based on NorFlash implementation available in NorFlashDxe.c
+
+  Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.
+  Copyright (c) 2015, Freescale Semiconductor, Inc. All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include <PiDxe.h>
+#include <Library/BaseMemoryLib/MemLibInternals.h>
+#include <Library/NorFlash.h>
+#include <Library/TimerLib.h>
+
+#include "CfiCommand.h"
+#include "CfiNorFlashLib.h"
+
+#define GET_BLOCK_OFFSET(Lba) ((Instance->RegionBaseAddress)-(Instance->DeviceBaseAddress)+((UINTN)((Lba) * Instance->Media.BlockSize)))
+
+NorFlashDescription mNorFlashDevices[NOR_FLASH_DEVICE_COUNT];
+
+STATIC VOID
+UnlockEraseAddress (
+  IN  UINTN  DeviceBaseAddress
+  )
+{  // Issue the Unlock cmds
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_ERASE_FIRST);
+
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_2_ADDR,
+                   CMD_ERASE_SECOND);
+
+  // Issue a setup command
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_ERASE_THIRD);
+
+  // Issue the Unlock cmds
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_ERASE_FOURTH);
+
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_2_ADDR,
+                   CMD_ERASE_FIFTH);
+
+  return;
+}
+
+STATIC
+UINT64
+ConvertMicroSecondsToTicks(
+  IN UINTN MicroSeconds
+)
+{
+  UINT64 TimerTicks64;
+
+  TimerTicks64 = 0;
+
+  // Calculate counter ticks that represent requested delay:
+  //  = MicroSeconds x TICKS_PER_MICRO_SEC
+  //  = MicroSeconds x Timer Frequency(in Hz) x 10^-6
+  // GetPerformanceCounterProperties = Get Arm Timer Frequency in Hz
+  TimerTicks64 = DivU64x32 (
+                   MultU64x64 (
+                     MicroSeconds,
+                     GetPerformanceCounterProperties (NULL, NULL)
+                     ),
+                   1000000U
+                   );
+  return TimerTicks64;
+}
+
+/**
+ * The following function erases a NOR flash sector.
+ **/
+EFI_STATUS
+NorFlashPlatformEraseSector (
+  IN NOR_FLASH_INSTANCE     *Instance,
+  IN UINTN                  SectorAddress
+  )
+{
+  FLASH_DATA EraseStatus1;
+  FLASH_DATA EraseStatus2;
+  UINT64     Timeout;
+  UINT64     SystemCounterVal;
+
+  EraseStatus1 = 0;
+  EraseStatus2 = 0;
+  Timeout = 0;
+
+  Timeout = ConvertMicroSecondsToTicks (
+                   mNorFlashDevices[Instance->Media.MediaId].BlockEraseTimeOut);
+  // Request a sector erase by writing two unlock cycles, followed by a
+  // setup command and two additional unlock cycles
+
+  UnlockEraseAddress (Instance->DeviceBaseAddress);
+
+  // Now send the address of the sector to be erased
+  SEND_NOR_COMMAND (SectorAddress, 0, CMD_SECTOR_ERASE_SIXTH);
+
+  // Wait for erase to complete
+  // Read Sector start address twice to detect bit toggle and to
+  // determine ERASE DONE (all bits are 1)
+  // Get the maximum timer ticks needed to complete the operation
+  // Check if operation is complete or not in continous loop?
+  // if complete, exit from loop
+  // if not check the ticks that have been passed from the begining of loop
+  // if Maximum Ticks allocated for operation has passed exit from loop
+
+  SystemCounterVal = GetPerformanceCounter ();
+  Timeout += SystemCounterVal;
+  while (SystemCounterVal < Timeout) {
+    if ((EraseStatus1 = FLASH_READ(SectorAddress)) ==
+            (EraseStatus2 = FLASH_READ(SectorAddress))) {
+      if (0xFFFF == FLASH_READ(SectorAddress)) {
+        break;
+      }
+    }
+    SystemCounterVal = GetPerformanceCounter ();
+  }
+
+  if(SystemCounterVal >= Timeout) {
+    DEBUG((DEBUG_ERROR, "%a :Failed to Erase @ SectorAddress 0x%p, Timeout\n",
+                __FUNCTION__, SectorAddress));
+    return EFI_DEVICE_ERROR;
+  } else {
+    return EFI_SUCCESS;
+  }
+}
+
+EFI_STATUS NorFlashPlatformWriteWord
+(
+  IN NOR_FLASH_INSTANCE      *Instance,
+  IN UINTN                   WordOffset,
+  IN FLASH_DATA              Word
+)
+{
+  UINT64        Timeout;
+  UINTN         TargetAddress;
+  UINT64        SystemCounterVal;
+  FLASH_DATA    Read1;
+  FLASH_DATA    Read2;
+
+  Timeout = 0;
+
+  Timeout = ConvertMicroSecondsToTicks(
+              mNorFlashDevices[Instance->Media.MediaId].WordWriteTimeOut);
+
+  TargetAddress = CREATE_NOR_ADDRESS(Instance->DeviceBaseAddress,
+              CREATE_BYTE_OFFSET(WordOffset));
+
+  // Issue the Unlock cmds
+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_PROGRAM_FIRST);
+
+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, CMD_UNLOCK_2_ADDR,
+                   CMD_PROGRAM_SECOND);
+
+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_PROGRAM_THIRD);
+
+  FLASH_WRITE_DATA (TargetAddress, Word);
+
+  // Wait for Write to Complete
+  // Read the last written address twice to detect bit toggle and
+  // to determine if date is wriiten successfully or not ?
+  // Get the maximum timer ticks needed to complete the operation
+  // Check if operation is complete or not in continous loop?
+  // if complete, exit from loop
+  // if not check the ticks that have been passed from the begining of loop
+  // if Maximum Ticks allocated for operation has passed, then exit from loop
+
+  SystemCounterVal = GetPerformanceCounter ();
+  Timeout += SystemCounterVal;
+  while (SystemCounterVal < Timeout) {
+    if ((Read1 = FLASH_READ_DATA(TargetAddress)) ==
+            (Read2 = FLASH_READ_DATA(TargetAddress))) {
+      if (Word == FLASH_READ_DATA(TargetAddress)) {
+        break;
+      }
+    }
+    SystemCounterVal = GetPerformanceCounter ();
+  }
+
+  if(SystemCounterVal >= Timeout) {
+    DEBUG((DEBUG_ERROR, "%a: Failed to  Write @ TargetAddress 0x%p, Timeout\n",
+                __FUNCTION__, TargetAddress));
+    return EFI_DEVICE_ERROR;
+  } else {
+    return EFI_SUCCESS;
+  }
+}
+
+EFI_STATUS NorFlashPlatformWritePageBuffer
+(
+  IN NOR_FLASH_INSTANCE      *Instance,
+  IN UINTN                   PageBufferOffset,
+  IN UINTN                   NumWords,
+  IN FLASH_DATA              *Buffer
+)
+{
+  UINT64        Timeout;
+  UINTN         LastWrittenAddress;
+  FLASH_DATA    LastWritenData;
+  UINTN         current_offset;
+  UINTN         end_offset;
+  UINTN         TargetAddress;
+  UINT64        SystemCounterVal;
+  FLASH_DATA    Read1;
+  FLASH_DATA    Read2;
+
+  // Initialize variables
+  Timeout = 0;
+  LastWrittenAddress = 0;
+  LastWritenData = 0;
+  current_offset   = PageBufferOffset;
+  end_offset       = PageBufferOffset + NumWords - 1;
+  Timeout   = ConvertMicroSecondsToTicks (
+                  mNorFlashDevices[Instance->Media.MediaId].BufferWriteTimeOut);
+  TargetAddress = CREATE_NOR_ADDRESS (Instance->DeviceBaseAddress,
+                     CREATE_BYTE_OFFSET (current_offset));
+
+  // don't try with a count of zero
+  if (!NumWords) {
+    return EFI_SUCCESS;
+  }
+  else if (NumWords == 1) {
+    return NorFlashPlatformWriteWord (Instance, PageBufferOffset, *Buffer);
+  }
+
+  // Issue the Unlock cmds
+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                   CMD_WRITE_TO_BUFFER_FIRST);
+
+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, CMD_UNLOCK_2_ADDR,
+                   CMD_WRITE_TO_BUFFER_SECOND);
+
+  // Write the buffer load
+  SEND_NOR_COMMAND (TargetAddress, 0, CMD_WRITE_TO_BUFFER_THIRD);
+
+  // Write # of locations to program
+  SEND_NOR_COMMAND (TargetAddress, 0, (NumWords - 1));
+
+  // Load Data into Buffer
+  while (current_offset <= end_offset) {
+    LastWrittenAddress = CREATE_NOR_ADDRESS (Instance->DeviceBaseAddress,
+                            CREATE_BYTE_OFFSET (current_offset++));
+    LastWritenData = *Buffer++;
+
+    // Write Data
+    FLASH_WRITE_DATA (LastWrittenAddress,LastWritenData);
+  }
+
+  // Issue the Buffered Program Confirm command
+  SEND_NOR_COMMAND (TargetAddress, 0, CMD_WRITE_TO_BUFFER_CONFIRM);
+
+  /* Wait for Write to Complete
+     Read the last written address twice to detect bit toggle and
+     to determine if date is wriiten successfully or not ?
+     Get the maximum timer ticks needed to complete the operation
+     Check if operation is complete or not in continous loop?
+     if complete, exit from loop
+     if not check the ticks that have been passed from the begining of loop
+     if Maximum Ticks allocated for operation has passed, then exit from loop **/
+  SystemCounterVal = GetPerformanceCounter();
+  Timeout += SystemCounterVal;
+  while (SystemCounterVal < Timeout) {
+    if ((Read1 = FLASH_READ_DATA (LastWrittenAddress)) ==
+            (Read2 = FLASH_READ_DATA (LastWrittenAddress))) {
+      if (LastWritenData == FLASH_READ_DATA (LastWrittenAddress)) {
+        break;
+      }
+    }
+    SystemCounterVal = GetPerformanceCounter ();
+  }
+
+  if (SystemCounterVal >= Timeout) {
+    DEBUG((DEBUG_ERROR, "%a: Failed to Write @LastWrittenAddress 0x%p, Timeout\n",
+                __FUNCTION__, LastWrittenAddress));
+    return EFI_DEVICE_ERROR;
+  } else {
+    return EFI_SUCCESS;
+  }
+}
+
+EFI_STATUS NorFlashPlatformWriteWordAlignedAddressBuffer
+(
+  IN NOR_FLASH_INSTANCE   *Instance,
+  IN UINTN                Offset,
+  IN UINTN                NumWords,
+  IN FLASH_DATA           *Buffer
+  )
+{
+  UINTN      MultiByteWordCount;
+  UINTN      Mask;
+  UINTN      IntWords;
+  EFI_STATUS Status;
+
+  MultiByteWordCount = mNorFlashDevices[Instance->Media.MediaId].MultiByteWordCount;
+  Mask = MultiByteWordCount - 1;
+  IntWords = NumWords;
+  Status = EFI_SUCCESS;
+
+  if (Offset & Mask)
+  {
+    // program only as much as necessary, so pick the lower of the two numbers
+    if (NumWords < (MultiByteWordCount - (Offset & Mask))) {
+      IntWords = NumWords;
+    }
+    else {
+      IntWords = MultiByteWordCount - (Offset & Mask);
+    }
+
+    // program the first few to get write buffer aligned
+    Status = NorFlashPlatformWritePageBuffer (Instance, Offset, IntWords, Buffer);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    Offset   += IntWords; // adjust pointers and counter
+    NumWords -= IntWords;
+    Buffer += IntWords;
+
+    if (NumWords == 0) {
+      return Status;
+    }
+  }
+
+  while (NumWords >= MultiByteWordCount) // while big chunks to do
+  {
+    Status = NorFlashPlatformWritePageBuffer (Instance, Offset,
+                            MultiByteWordCount, Buffer);
+    if (EFI_ERROR (Status)) {
+      return (Status);
+    }
+
+    Offset   += MultiByteWordCount; // adjust pointers and counter
+    NumWords -= MultiByteWordCount;
+    Buffer   += MultiByteWordCount;
+  }
+  if (NumWords == 0) {
+    return (Status);
+  }
+
+  Status = NorFlashPlatformWritePageBuffer (Instance, Offset, NumWords, Buffer);
+  return (Status);
+}
+
+/*
+ * Writes data to the NOR Flash using the Buffered Programming method.
+ *
+ * Write Buffer Programming allows the system to write a maximum of 32 bytes
+ * in one programming operation. Therefore this function will only handle
+ * buffers up to 32 bytes.
+ * To deal with larger buffers, call this function again.
+ */
+EFI_STATUS
+NorFlashPlatformWriteBuffer (
+  IN        NOR_FLASH_INSTANCE     *Instance,
+  IN        EFI_LBA                Lba,
+  IN        UINTN                  Offset,
+  IN OUT    UINTN                  *NumBytes,
+  IN        UINT8                  *Buffer
+  )
+{
+  EFI_STATUS        Status;
+  FLASH_DATA        *pSrcBuffer;
+  UINTN             TargetOffsetinBytes;
+  UINTN             WordsToWrite;
+  UINTN             Mask;
+  UINTN             BufferSizeInBytes;
+  UINTN             IntBytes;
+  UINT8             *CopyFrom, *CopyTo;
+  FLASH_DATA        TempWrite = 0;
+
+  pSrcBuffer = (FLASH_DATA *)Buffer;
+  TargetOffsetinBytes = 0;
+  WordsToWrite = 0;
+  Mask = sizeof(FLASH_DATA) - 1;
+  BufferSizeInBytes = *NumBytes;
+  IntBytes = BufferSizeInBytes; // Intermediate Bytes needed to copy for alignment
+  TempWrite = 0;
+
+  DEBUG ((DEBUG_BLKIO, "%a(Parameters: Lba=%ld, Offset=0x%x, "
+                        "*NumBytes=0x%x, Buffer @ 0x%08x)\n",
+                        __FUNCTION__, Lba, Offset, *NumBytes, Buffer));
+
+  TargetOffsetinBytes = GET_BLOCK_OFFSET (Lba) + (UINTN)(Offset);
+
+  if (TargetOffsetinBytes & Mask) {
+    // Write only as much as necessary, so pick the lower of the two numbers
+    // and call it Intermediate bytes to write to make alignment proper
+    if (BufferSizeInBytes < (sizeof(FLASH_DATA) - (TargetOffsetinBytes & Mask))) {
+      IntBytes = BufferSizeInBytes;
+    }
+    else {
+      IntBytes = sizeof(FLASH_DATA) - (TargetOffsetinBytes & Mask);
+    }
+
+    // Read the first few to get Read buffer aligned
+    NorFlashPlatformRead (Instance, Lba, (TargetOffsetinBytes & ~Mask) -
+            GET_BLOCK_OFFSET (Lba), sizeof(TempWrite), (UINT8*)&TempWrite);
+
+    CopyTo = (UINT8*)&TempWrite;
+    CopyTo += (TargetOffsetinBytes & Mask);
+    CopyFrom = (UINT8*)Buffer;
+
+    InternalMemCopyMem (CopyTo, CopyFrom, IntBytes);
+
+    Status = NorFlashPlatformWriteWordAlignedAddressBuffer (Instance,
+                                (UINTN)((TargetOffsetinBytes & ~Mask)/sizeof(FLASH_DATA)),
+                                1, &TempWrite);
+    if (EFI_ERROR (Status)) {
+      DEBUG((DEBUG_ERROR, "%a : Failed to Write @TargetOffset 0x%x (0x%x)\n",
+                  __FUNCTION__, TargetOffsetinBytes, Status));
+      goto EXIT;
+    }
+
+    TargetOffsetinBytes += IntBytes; /* adjust pointers and counter */
+    BufferSizeInBytes -= IntBytes;
+    Buffer += IntBytes;
+
+    if (BufferSizeInBytes == 0) {
+      goto EXIT;
+    }
+  }
+
+  // Write the bytes to CFI width aligned address.
+  // Note we can Write number of bytes=CFI width in one operation
+  WordsToWrite = BufferSizeInBytes/sizeof(FLASH_DATA);
+  pSrcBuffer = (FLASH_DATA*)Buffer;
+
+  Status = NorFlashPlatformWriteWordAlignedAddressBuffer (
+                     Instance,
+                     (UINTN)(TargetOffsetinBytes/sizeof(FLASH_DATA)),
+                     WordsToWrite,
+                     pSrcBuffer);
+  if (EFI_ERROR(Status)) {
+    DEBUG((DEBUG_ERROR, "%a : Failed to Write @ TargetOffset 0x%x (0x%x)\n",
+            __FUNCTION__, TargetOffsetinBytes, Status));
+    goto EXIT;
+  }
+
+  BufferSizeInBytes -= (WordsToWrite*sizeof(FLASH_DATA));
+  Buffer += (WordsToWrite*sizeof(FLASH_DATA));
+  TargetOffsetinBytes += (WordsToWrite*sizeof(FLASH_DATA));
+
+  if (BufferSizeInBytes == 0) {
+    goto EXIT;
+  }
+
+  // Now Write bytes that are remaining and are less than CFI width.
+  // Read the first few to get Read buffer aligned
+  NorFlashPlatformRead (Instance,
+          Lba,
+          TargetOffsetinBytes - GET_BLOCK_OFFSET (Lba),
+          sizeof(TempWrite),
+          (UINT8*)&TempWrite);
+
+  CopyFrom = (UINT8*)Buffer;
+  CopyTo = (UINT8*)&TempWrite;
+
+  InternalMemCopyMem (CopyTo, CopyFrom, BufferSizeInBytes);
+
+  Status = NorFlashPlatformWriteWordAlignedAddressBuffer (Instance,
+                            (UINTN)(TargetOffsetinBytes/sizeof(FLASH_DATA)),
+                            1,
+                            &TempWrite);
+  if (EFI_ERROR(Status)) {
+    DEBUG((DEBUG_ERROR, "%a: Failed to Write @TargetOffset 0x%x Status=%d\n",
+                __FUNCTION__, TargetOffsetinBytes, Status));
+    goto EXIT;
+  }
+
+EXIT:
+  // Put device back into Read Array mode (via Reset)
+  NorFlashPlatformReset (Instance->DeviceBaseAddress);
+  return (Status);
+}
+
+EFI_STATUS
+NorFlashPlatformRead (
+  IN  NOR_FLASH_INSTANCE  *Instance,
+  IN  EFI_LBA             Lba,
+  IN  UINTN               Offset,
+  IN  UINTN               BufferSizeInBytes,
+  OUT UINT8               *Buffer
+  )
+{
+  UINTN               IntBytes;
+  UINTN               Mask;
+  FLASH_DATA          TempRead;
+  UINT8               *CopyFrom, *CopyTo;
+  UINTN               TargetOffsetinBytes;
+  FLASH_DATA          *pReadData;
+  UINTN               BlockSize;
+
+  IntBytes = BufferSizeInBytes; // Intermediate Bytes needed to copy for alignment
+  Mask = sizeof(FLASH_DATA) - 1;
+  TempRead = 0;
+  TargetOffsetinBytes = (UINTN)(GET_BLOCK_OFFSET (Lba) + Offset);
+  BlockSize = Instance->Media.BlockSize;
+
+  DEBUG ((DEBUG_BLKIO, "%a(Parameters: Lba=%ld, Offset=0x%x,"
+              " BufferSizeInBytes=0x%x, Buffer @ 0x%p)\n",
+              __FUNCTION__, Lba, Offset, BufferSizeInBytes, Buffer));
+
+  // 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 * BlockSize) + BufferSizeInBytes) > Instance->Size) {
+    DEBUG ((DEBUG_ERROR, "%a : Read will exceed device size.\n", __FUNCTION__));
+    return EFI_INVALID_PARAMETER;
+  }
+
+  // Put device back into Read Array mode (via Reset)
+  NorFlashPlatformReset (Instance->DeviceBaseAddress);
+
+  // First Read bytes to make buffer aligned to CFI width
+  if (TargetOffsetinBytes & Mask) {
+    // Read only as much as necessary, so pick the lower of the two numbers
+    if (BufferSizeInBytes < (sizeof(FLASH_DATA) - (TargetOffsetinBytes & Mask))) {
+      IntBytes = BufferSizeInBytes;
+    }
+    else {
+      IntBytes = sizeof(FLASH_DATA) - (TargetOffsetinBytes & Mask);
+    }
+
+    // Read the first few to get Read buffer aligned
+    TempRead = FLASH_READ_DATA (CREATE_NOR_ADDRESS (
+                     Instance->DeviceBaseAddress,
+                     CREATE_BYTE_OFFSET ((TargetOffsetinBytes & ~Mask)/sizeof(FLASH_DATA))));
+
+    CopyFrom = (UINT8*)&TempRead;
+    CopyFrom += (TargetOffsetinBytes & Mask);
+    CopyTo = (UINT8*)Buffer;
+
+    InternalMemCopyMem (CopyTo, CopyFrom, IntBytes);
+
+    TargetOffsetinBytes += IntBytes; // adjust pointers and counter
+    BufferSizeInBytes -= IntBytes;
+    Buffer += IntBytes;
+    if (BufferSizeInBytes == 0) {
+      return EFI_SUCCESS;
+    }
+  }
+
+  pReadData = (FLASH_DATA*)Buffer;
+
+  // Readout the bytes from CFI width aligned address.
+  // Note we can read number of bytes=CFI width in one operation
+  while (BufferSizeInBytes >= sizeof(FLASH_DATA)) {
+    *pReadData = FLASH_READ_DATA (CREATE_NOR_ADDRESS (
+                     Instance->DeviceBaseAddress,
+                     CREATE_BYTE_OFFSET (TargetOffsetinBytes/sizeof(FLASH_DATA))));
+    pReadData += 1;
+    BufferSizeInBytes -= sizeof(FLASH_DATA);
+    TargetOffsetinBytes += sizeof(FLASH_DATA);
+  }
+  if (BufferSizeInBytes == 0) {
+    return EFI_SUCCESS;
+  }
+
+  // Now read bytes that are remaining and are less than CFI width.
+  CopyTo = (UINT8*)pReadData;
+  // Read the first few to get Read buffer aligned
+  TempRead = FLASH_READ_DATA (CREATE_NOR_ADDRESS (
+                     Instance->DeviceBaseAddress,
+                     CREATE_BYTE_OFFSET (TargetOffsetinBytes/sizeof(FLASH_DATA))));
+  CopyFrom = (UINT8*)&TempRead;
+
+  InternalMemCopyMem (CopyTo, CopyFrom, BufferSizeInBytes);
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NorFlashPlatformReset (
+  IN  UINTN  DeviceBaseAddress
+  )
+{
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_1_ADDR,
+                     CMD_RESET_FIRST);
+
+  SEND_NOR_COMMAND (DeviceBaseAddress, CMD_UNLOCK_2_ADDR,
+                     CMD_RESET_SECOND);
+
+  SEND_NOR_COMMAND (DeviceBaseAddress, 0, CMD_RESET);
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NorFlashPlatformGetDevices (
+  OUT NorFlashDescription **NorFlashDevices,
+  OUT UINT32              *Count
+  )
+{
+  if ((NorFlashDevices == NULL) || (Count == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  // Get the number of NOR flash devices supported
+  *NorFlashDevices = mNorFlashDevices;
+  *Count = NOR_FLASH_DEVICE_COUNT;
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NorFlashPlatformFlashGetAttributes (
+  OUT NorFlashDescription *NorFlashDevices,
+  IN UINT32               Count
+  )
+{
+  EFI_STATUS              Status;
+  UINT32                  Index;
+
+  if ((NorFlashDevices == NULL) || (Count == 0)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  // Check the attributes of the NOR flash slave we are connected to.
+  // Currently we support only CFI flash devices. Bail-out otherwise.
+  Status = CfiNorFlashFlashGetAttributes (NorFlashDevices, Count);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  // Limit the Size of Nor Flash that can be programmed
+  for (Index = 0; Index < Count; Index++) {
+    NorFlashDevices[Index].RegionBaseAddress = PcdGet64 (PcdFlashReservedRegionBase64);
+    NorFlashDevices[Index].Size -= (NorFlashDevices[Index].RegionBaseAddress -
+                                    NorFlashDevices[Index].DeviceBaseAddress);
+    if((NorFlashDevices[Index].RegionBaseAddress - NorFlashDevices[Index].DeviceBaseAddress) %
+                NorFlashDevices[Index].BlockSize) {
+      DEBUG ((DEBUG_ERROR, "%a : Reserved Region(0x%p) doesn't start "
+                  "from block boundry(0x%08x)\n", __FUNCTION__,
+                  (UINTN)NorFlashDevices[Index].RegionBaseAddress,
+                  (UINT32)NorFlashDevices[Index].BlockSize));
+      return EFI_DEVICE_ERROR;
+    }
+  }
+  return Status;
+}
diff --git a/Platform/NXP/Library/NorFlashLib/NorFlashLib.inf b/Platform/NXP/Library/NorFlashLib/NorFlashLib.inf
new file mode 100644
index 0000000..14ca0ab
--- /dev/null
+++ b/Platform/NXP/Library/NorFlashLib/NorFlashLib.inf
@@ -0,0 +1,42 @@
+#/** @NorFlashLib.inf
+#
+#  Component description file for NorFlashLib module
+#
+#  Copyright 2017 NXP
+#
+#  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                    = 0x0001001A
+  BASE_NAME                      = NorFlashLib
+  FILE_GUID                      = f3176a49-dde1-450d-a909-8580c03b9ba8
+  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = NorFlashLib
+
+[Sources.common]
+  NorFlashLib.c
+  IfcNorFlashLib.c
+  CfiNorFlashLib.c
+
+[LibraryClasses]
+  ArmLib
+  IfcFlashLib
+  TimerLib
+
+[Packages]
+  ArmPkg/ArmPkg.dec
+  MdePkg/MdePkg.dec
+  Platform/NXP/NxpQoriqLs.dec
+
+[Pcd.common]
+  gNxpQoriqLsTokenSpaceGuid.PcdFlashDeviceBase64
+  gNxpQoriqLsTokenSpaceGuid.PcdFlashReservedRegionBase64
-- 
1.9.1