This patch adds 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..7e798dc
--- /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
_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel
© 2016 - 2024 Red Hat, Inc.