On Fri, Feb 16, 2018 at 02:20:11PM +0530, Meenakshi wrote: > From: Meenakshi Aggarwal <meenakshi.aggar...@nxp.com> > > NorFlashLib interacts with the underlying IFC NOR controller. > This will be used by NOR driver for any information > exchange with NOR controller.
Some of this looks generic CFI which should at some point be broken out in its own library. Let's not worray about that for now, but I wanted to mention it :) > > Contributed-under: TianoCore Contribution Agreement 1.1 > Signed-off-by: Meenakshi Aggarwal <meenakshi.aggar...@nxp.com> > --- > Silicon/NXP/Include/Library/NorFlashLib.h | 77 +++ > Silicon/NXP/Include/NorFlash.h | 48 ++ > Silicon/NXP/Library/NorFlashLib/CfiCommand.h | 99 ++++ > Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c | 233 ++++++++ > Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h | 68 +++ > Silicon/NXP/Library/NorFlashLib/NorFlashLib.c | 660 > +++++++++++++++++++++++ > Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf | 41 ++ > 7 files changed, 1226 insertions(+) > create mode 100644 Silicon/NXP/Include/Library/NorFlashLib.h > create mode 100644 Silicon/NXP/Include/NorFlash.h > create mode 100644 Silicon/NXP/Library/NorFlashLib/CfiCommand.h > create mode 100644 Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c > create mode 100644 Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h > create mode 100644 Silicon/NXP/Library/NorFlashLib/NorFlashLib.c > create mode 100644 Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf > > diff --git a/Silicon/NXP/Include/Library/NorFlashLib.h > b/Silicon/NXP/Include/Library/NorFlashLib.h > new file mode 100644 > index 0000000..defdc61 > --- /dev/null > +++ b/Silicon/NXP/Include/Library/NorFlashLib.h > @@ -0,0 +1,77 @@ > +/** @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 <NorFlash.h> > + > +#define NOR_FLASH_DEVICE_COUNT 1 > + > +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 > + ); > + > +EFI_STATUS > +NorFlashPlatformWriteBuffer ( > + IN NOR_FLASH_INSTANCE *Instance, > + IN EFI_LBA Lba, > + IN UINTN Offset, > + IN OUT UINTN *NumBytes, > + IN UINT8 *Buffer > + ); > + > +EFI_STATUS > +NorFlashPlatformEraseSector ( > + IN NOR_FLASH_INSTANCE *Instance, > + IN UINTN SectorAddress > + ); > + > +EFI_STATUS > +NorFlashPlatformRead ( > + IN NOR_FLASH_INSTANCE *Instance, > + IN EFI_LBA Lba, > + IN UINTN Offset, > + IN UINTN BufferSizeInBytes, > + OUT UINT8 *Buffer > + ); > + > +EFI_STATUS > +NorFlashPlatformReset ( > + IN UINTN Instance > + ); > + > +#endif /* _NOR_FLASH_LIB_H_ */ > diff --git a/Silicon/NXP/Include/NorFlash.h b/Silicon/NXP/Include/NorFlash.h > new file mode 100644 > index 0000000..888f5c1 > --- /dev/null > +++ b/Silicon/NXP/Include/NorFlash.h > @@ -0,0 +1,48 @@ > +/** @NorFlash.h > + > + Contains data structure shared by both NOR Library and Driver. > + 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_H__ > +#define __NOR_FLASH_H__ > + > +#include <Protocol/BlockIo.h> > +#include <Protocol/FirmwareVolumeBlock.h> > + > +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 DeviceBaseAddress; > + UINTN RegionBaseAddress; > + UINTN Size; > + EFI_LBA StartLba; > + EFI_BLOCK_IO_PROTOCOL BlockIoProtocol; > + EFI_BLOCK_IO_MEDIA Media; > + BOOLEAN SupportFvb; > + EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol; > + VOID* ShadowBuffer; > + NOR_FLASH_DEVICE_PATH DevicePath; > +}; > + > + > +#endif /* __NOR_FLASH_H__ */ > diff --git a/Silicon/NXP/Library/NorFlashLib/CfiCommand.h > b/Silicon/NXP/Library/NorFlashLib/CfiCommand.h > new file mode 100644 > index 0000000..8543227 > --- /dev/null > +++ b/Silicon/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 Command > + > +// PROGRAM Command > +#define CMD_PROGRAM_FIRST 0xAA > +#define CMD_PROGRAM_SECOND 0x55 > +#define CMD_PROGRAM_THIRD 0xA0 > + > +// Write Buffer Command > +#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 Command > + > +// 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 Command > +#define CMD_CHIP_ERASE_SIXTH 0x10 > + > +// Sector Erase Command > +#define CMD_SECTOR_ERASE_SIXTH 0x30 > + > +// SUSPEND Command > +#define CMD_PROGRAM_OR_ERASE_SUSPEND 0xB0 > +#define CMD_PROGRAM_OR_ERASE_RESUME 0x30 > + > +#endif // __CFI_COMMAND_H__ > diff --git a/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c > b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c > new file mode 100644 > index 0000000..632e943 > --- /dev/null > +++ b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c > @@ -0,0 +1,233 @@ > +/** @CfiNorFlashLib.c > + > + Copyright (c) 2015, Freescale Semiconductor, Inc. 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. > + > + **/ > + > +#include <PiDxe.h> > +#include <Library/ArmLib.h> > +#include <Library/BaseLib.h> > + > +#include "CfiCommand.h" > +#include "CfiNorFlashLib.h" > + > +FLASH_DATA > +IfcNorFlashData ( > + IN OUT FLASH_DATA Value > + ) > +{ > + if (FixedPcdGetBool (PcdIfcBigEndian)) { > + return SwapBytes16 (Value); > + } else { > + return Value; > + } > +} > + > +/** > + Write Val at given address. > + > + @param Val Data to be written. > + @param Addr Address where data is to be written. > + > +**/ > +VOID > +FlashWriteData ( > + IN FLASH_DATA Val, > + IN UINTN Addr > + ) > +{ > + *(volatile FLASH_DATA *)(Addr) = (Val); > +} > + > +/** > + Check endianness of IFC Controller and depending on swap > + the data and write on given address. > + > + @param Val Data to be written. > + @param Addr Address where data is to be written. > + > +**/ > +VOID > +FlashWrite ( > + IN FLASH_DATA Val, > + IN UINTN Addr > + ) > +{ > + FLASH_DATA ShiftVal; > + > + ShiftVal = IfcNorFlashData (Val); > + > + *(volatile FLASH_DATA *)(Addr) = (ShiftVal); > +} > + > +/** > + Read data from given address. > + > + @param Addr Address from where data is to be read. > + > + @return Read Data > +**/ > +FLASH_DATA > +FlashReadData ( > + IN UINTN Addr > + ) > +{ > + FLASH_DATA Val; > + > + Val = *(volatile FLASH_DATA *)(Addr); > + > + return (Val); > +} > + > +/** > + Read data from given address and depending on endianness of IFC Controller > + swap the read data. > + > + @param Addr Address from where data is to be read. > + > + @return Read Data > +**/ > +FLASH_DATA > +FlashRead ( > + IN UINTN Addr > + ) > +{ > + FLASH_DATA Val; > + FLASH_DATA ShiftVal; > + > + Val = *(volatile FLASH_DATA *)(Addr); > + ShiftVal = IfcNorFlashData (Val); > + > + return (ShiftVal); > +} Instead of the above, please use same mechanisms as watchdog, gur(?), ifc. > + > +STATIC > +VOID > +NorFlashReadCfiData ( > + IN UINTN DeviceBaseAddress, > + IN UINTN CfiOffset, > + 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 + > CfiOffset)); > + CfiOffset++; > + } > +} > + > +/* > + 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]; > + FLASH_DATA BlockSize[2]; > + UINTN DeviceBaseAddress; > + FLASH_DATA MaxNumBytes[2]; > + FLASH_DATA Size; > + FLASH_DATA HighByteMask; // Masks High byte in a UIN16 word > + FLASH_DATA HighByteShift; // Bitshifts needed to make a byte > High Byte in a UIN16 word > + FLASH_DATA Temp1; > + FLASH_DATA Temp2; > + > + HighByteMask = 0xFF; > + HighByteShift = 8; > + > + 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); Indentation. > + > + ArmDataSynchronizationBarrier (); I would prefer the use of a MemoryFence() here. In fact, ArmDataSynchronizationBarrier () is inappropriate in this location anyway. > + > + // Query the unique QRY > + NorFlashReadCfiData (DeviceBaseAddress, > + CFI_QUERY_UNIQUE_QRY_STRING, > + 3, What's 3 here? Could it be replaced by a macro or define? > + &QryData); Indentation. Please have a look throughout this file. > + if (QryData[0] != (FLASH_DATA)CFI_QRY_Q || QryData[1] != > + (FLASH_DATA)CFI_QRY_R || QryData[2] != (FLASH_DATA)CFI_QRY_Y ) { Some added parentheses please. > + 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); What's 1 here? Could it be replaced by a macro or define? > + // Refer CFI Specification > + NorFlashDevices[Count].Size = 1 << Size; > + > + NorFlashReadCfiData (DeviceBaseAddress, CFI_QUERY_BLOCK_SIZE, > + 2, &BlockSize); What's 2 here? Could it be replaced by a macro or define? > + // Refer CFI Specification > + NorFlashDevices[Count].BlockSize = 256 * ((FLASH_DATA) ((BlockSize[1] << What's 256 here? Could it be replaced by a macro or define? > + 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); What's 1 here? Could it be replaced by a macro or define? (Same question repeated throughout.) > + 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; * 1000 - microseconds to milliseconds? > + > + 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/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h > b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h > new file mode 100644 > index 0000000..91d50f0 > --- /dev/null > +++ b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h > @@ -0,0 +1,68 @@ > +/** @CfiNorFlashLib.h > + > + Copyright (c) 2015, Freescale Semiconductor, Inc. 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 __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 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) FlashWriteData ((Val), > (Addr)) > +#define SEND_NOR_COMMAND(BaseAddr, Offset, Cmd) FLASH_WRITE > (CREATE_NOR_ADDRESS (BaseAddr, CREATE_BYTE_OFFSET (Offset)), (Cmd)) > + > +typedef UINT16 FLASH_DATA; > + > +VOID > +FlashWrite ( > + IN FLASH_DATA Val, > + IN UINTN Addr > + ); > + > +FLASH_DATA > +FlashRead ( > + IN UINTN Addr > + ); > + > +VOID > +FlashWriteData ( > + IN FLASH_DATA Val, > + IN UINTN Addr > + ); > + > +FLASH_DATA > +FlashReadData ( > + IN UINTN Addr > + ); > + > +EFI_STATUS > +CfiNorFlashFlashGetAttributes ( > + OUT NorFlashDescription *NorFlashDevices, > + IN UINT32 Index > + ); > + > +#endif //__CFI_NOR_FLASH_LIB_H__ > diff --git a/Silicon/NXP/Library/NorFlashLib/NorFlashLib.c > b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.c > new file mode 100644 > index 0000000..b74e9eb > --- /dev/null > +++ b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.c > @@ -0,0 +1,660 @@ > +/** @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. > + 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. > + > +**/ > + > +#include <PiDxe.h> > +#include <Library/BaseMemoryLib/MemLibInternals.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); Indentation. > + > + 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); Indentation. > + // 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))) { Indentation. > + if (0xFFFF == FLASH_READ (SectorAddress)) { No jeopardy compares, please. if (FLASH_READ (SectorAddress) == 0xFFFF) { > + 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))) { Indentation. > + 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 CurrentOffset; > + UINTN EndOffset; > + UINTN TargetAddress; > + UINT64 SystemCounterVal; > + FLASH_DATA Read1; > + FLASH_DATA Read2; > + > + // Initialize variables > + Timeout = 0; > + LastWrittenAddress = 0; > + LastWritenData = 0; > + CurrentOffset = PageBufferOffset; > + EndOffset = PageBufferOffset + NumWords - 1; > + Timeout = ConvertMicroSecondsToTicks ( > + > mNorFlashDevices[Instance->Media.MediaId].BufferWriteTimeOut); > + TargetAddress = CREATE_NOR_ADDRESS (Instance->DeviceBaseAddress, > + CREATE_BYTE_OFFSET (CurrentOffset)); > + > + // don't try with a count of zero > + if (!NumWords) { > + return EFI_SUCCESS; > + } > + else if (NumWords == 1) { else on same line as } > + 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 (CurrentOffset <= EndOffset) { > + LastWrittenAddress = CREATE_NOR_ADDRESS (Instance->DeviceBaseAddress, > + CREATE_BYTE_OFFSET (CurrentOffset++)); > + 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))) { Indentation. > + 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 > + ) > +{ > + EFI_STATUS Status; > + UINTN MultiByteWordCount; > + UINTN Mask; > + UINTN IntWords; > + > + 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 *SrcBuffer; > + UINTN TargetOffsetinBytes; > + UINTN WordsToWrite; > + UINTN Mask; > + UINTN BufferSizeInBytes; > + UINTN IntBytes; > + UINT8 *CopyFrom; > + UINT8 *CopyTo; VOID* (x2) > + FLASH_DATA TempWrite; > + > + SrcBuffer = (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); Please use CopyMem instead. > + > + 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); > + SrcBuffer = (FLASH_DATA*)Buffer; > + > + Status = NorFlashPlatformWriteWordAlignedAddressBuffer ( > + Instance, > + (UINTN)(TargetOffsetinBytes/sizeof (FLASH_DATA)), > + WordsToWrite, > + SrcBuffer); > + 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); Please use CopyMem instead. > + > + 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; > + UINT8 *CopyTo; Don't use UINT8* where VOID* is intended. > + UINTN TargetOffsetinBytes; > + FLASH_DATA *ReadData; > + 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; That way you can also get rid of these casts. > + > + InternalMemCopyMem (CopyTo, CopyFrom, IntBytes); Please use CopyMem instead. > + > + TargetOffsetinBytes += IntBytes; // adjust pointers and counter > + BufferSizeInBytes -= IntBytes; > + Buffer += IntBytes; > + if (BufferSizeInBytes == 0) { > + return EFI_SUCCESS; > + } > + } > + > + ReadData = (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)) { > + *ReadData = FLASH_READ_DATA (CREATE_NOR_ADDRESS ( > + Instance->DeviceBaseAddress, > + CREATE_BYTE_OFFSET (TargetOffsetinBytes/sizeof > (FLASH_DATA)))); > + ReadData += 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*)ReadData; > + // 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; And these. > + > + InternalMemCopyMem (CopyTo, CopyFrom, BufferSizeInBytes); Please use CopyMem instead. > + > + 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/Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf > b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf > new file mode 100644 > index 0000000..403766a > --- /dev/null > +++ b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf > @@ -0,0 +1,41 @@ > +# @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 > + CfiNorFlashLib.c Please sort alphabetically. > + > +[LibraryClasses] > + ArmLib > + TimerLib > + > +[Packages] > + ArmPkg/ArmPkg.dec > + MdePkg/MdePkg.dec > + Silicon/NXP/NxpQoriqLs.dec > + > +[Pcd.common] > + gNxpQoriqLsTokenSpaceGuid.PcdFlashDeviceBase64 > + gNxpQoriqLsTokenSpaceGuid.PcdFlashReservedRegionBase64 > + gNxpQoriqLsTokenSpaceGuid.PcdIfcBigEndian > + gNxpQoriqLsTokenSpaceGuid.PcdIfcNandReservedSize > -- > 1.9.1 > _______________________________________________ edk2-devel mailing list edk2-devel@lists.01.org https://lists.01.org/mailman/listinfo/edk2-devel
