NorFlashLib interacts with the underlying IFC NOR controller. This will be used by NOR driver for any information exchange with NOR controller.
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 | 44 ++ Silicon/NXP/Library/NorFlashLib/CfiCommand.h | 99 ++++ Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c | 210 +++++++ Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h | 53 ++ Silicon/NXP/Library/NorFlashLib/NorFlashLib.c | 696 +++++++++++++++++++++++ Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf | 43 ++ 7 files changed, 1222 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..8fa41d8 --- /dev/null +++ b/Silicon/NXP/Include/NorFlash.h @@ -0,0 +1,44 @@ +/** @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 struct { + VENDOR_DEVICE_PATH Vendor; + EFI_DEVICE_PATH_PROTOCOL End; +} NOR_FLASH_DEVICE_PATH; + +struct _NOR_FLASH_INSTANCE { + UINT32 Signature; + EFI_HANDLE Handle; + UINTN DeviceBaseAddress; + UINTN RegionBaseAddress; + UINTN Size; + EFI_LBA StartLba; + EFI_BLOCK_IO_PROTOCOL BlockIoProtocol; + EFI_BLOCK_IO_MEDIA Media; + 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..941d5d4 --- /dev/null +++ b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.c @@ -0,0 +1,210 @@ +/** @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" + +STATIC +VOID +NorFlashReadCfiData ( + IN UINTN DeviceBaseAddress, + IN UINTN CfiOffset, + IN UINT32 Count, + OUT VOID *Data + ) +{ + UINT32 Loop; + FLASH_DATA *TmpData = (FLASH_DATA *)Data; + + for (Loop = 0; Loop < Count; Loop++, TmpData++) { + *TmpData = mMmioOps->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[QRY_STRING_COUNT]; + FLASH_DATA BlockSize[BLOCK_SIZE_COUNT]; + UINTN DeviceBaseAddress; + FLASH_DATA MaxNumBytes[BLOCK_SIZE_COUNT]; + 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; + FLASH_DATA Z; + + 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 + ); + + MemoryFence(); + + // Query the unique QRY + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_UNIQUE_QRY_STRING, + QRY_STRING_COUNT, + &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, + DEVICE_SIZE_COUNT, + &Size + ); + + // Refer CFI Specification [2^n in number of bytes.] + NorFlashDevices[Count].Size = 1 << Size; + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_BLOCK_SIZE, + BLOCK_SIZE_COUNT, + &BlockSize + ); + + // Refer CFI Specification [Erase block(s) within this region are (z) times 256 bytes in size. + // The value z = 0 is used for 128-byte block size. + Z = (FLASH_DATA)((BlockSize[1] << HighByteShift) | (BlockSize[0] & HighByteMask)); + if (Z == 0) { + NorFlashDevices[Count].BlockSize = 128; + } else { + NorFlashDevices[Count].BlockSize = 256 * Z; + } + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_MAX_NUM_BYTES_WRITE, + BLOCK_SIZE_COUNT, + &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, + WORD_WRITE_COUNT, + &Temp1 + ); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_MAX_TIMEOUT_WORD_WRITE, + WORD_WRITE_COUNT, + &Temp2 + ); + + NorFlashDevices[Count].WordWriteTimeOut = (1U << Temp1) * (1U << Temp2); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_TYP_TIMEOUT_MAX_BUFFER_WRITE, + BUFFER_WRITE_COUNT, + &Temp1 + ); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_MAX_TIMEOUT_MAX_BUFFER_WRITE, + BUFFER_WRITE_COUNT, + &Temp2 + ); + + NorFlashDevices[Count].BufferWriteTimeOut = (1U << Temp1) * (1U << Temp2); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_TYP_TIMEOUT_BLOCK_ERASE, + BLOCK_ERASE_COUNT, + &Temp1 + ); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_MAX_TIMEOUT_BLOCK_ERASE, + BLOCK_ERASE_COUNT, + &Temp2 + ); + + // Converting from millisecond to microseconds + NorFlashDevices[Count].BlockEraseTimeOut = (1U << Temp1) * (1U << Temp2) * 1000; + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_TYP_TIMEOUT_CHIP_ERASE, + CHIP_ERASE_COUNT, + &Temp1 + ); + + NorFlashReadCfiData ( + DeviceBaseAddress, + CFI_QUERY_MAX_TIMEOUT_CHIP_ERASE, + CHIP_ERASE_COUNT, + &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..710f706 --- /dev/null +++ b/Silicon/NXP/Library/NorFlashLib/CfiNorFlashLib.h @@ -0,0 +1,53 @@ +/** @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/IoAccessLib.h> +#include <Library/NorFlashLib.h> + +extern MMIO_OPERATIONS_16 *mMmioOps; + +/* + * 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 QRY_STRING_COUNT 3 +#define DEVICE_SIZE_COUNT 1 +#define BLOCK_SIZE_COUNT 2 +#define WORD_WRITE_COUNT 1 +#define BUFFER_WRITE_COUNT 1 +#define BLOCK_ERASE_COUNT 1 +#define CHIP_ERASE_COUNT 1 + +#define CREATE_BYTE_OFFSET(OffsetAddr) ((sizeof (FLASH_DATA)) * (OffsetAddr)) +#define CREATE_NOR_ADDRESS(BaseAddr, OffsetAddr) ((BaseAddr) + (OffsetAddr)) +#define SEND_NOR_COMMAND(BaseAddr, Offset, Cmd) mMmioOps->Write (CREATE_NOR_ADDRESS (BaseAddr, CREATE_BYTE_OFFSET (Offset)), (Cmd)) + +typedef UINT16 FLASH_DATA; + +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..c89ddc3 --- /dev/null +++ b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.c @@ -0,0 +1,696 @@ +/** @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/IoAccessLib.h> +#include <Library/IoLib.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))) + +MMIO_OPERATIONS_16 *mMmioOps; + +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 = mMmioOps->Read (SectorAddress)) + == (EraseStatus2 = mMmioOps->Read (SectorAddress))) + { + if (mMmioOps->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); + + MmioWrite16 (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 = MmioRead16 (TargetAddress)) + == (Read2 = MmioRead16 (TargetAddress))) + { + if (Word == MmioRead16 (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) { + 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 + MmioWrite16 (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 = MmioRead16 (LastWrittenAddress)) + == (Read2 = MmioRead16 (LastWrittenAddress))) + { + if (LastWritenData == MmioRead16 (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; + VOID *CopyFrom; + VOID *CopyTo; + 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 = Buffer; + + CopyMem (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); + 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 = Buffer; + CopyTo = &TempWrite; + + CopyMem (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; + VOID *CopyFrom; + VOID *CopyTo; + 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 = MmioRead16 ( + CREATE_NOR_ADDRESS ( + Instance->DeviceBaseAddress, + CREATE_BYTE_OFFSET ((TargetOffsetinBytes & ~Mask) / sizeof (FLASH_DATA)) + ) + ); + + CopyFrom = (UINT8*)&TempRead; + CopyFrom += (TargetOffsetinBytes & Mask); + CopyTo = Buffer; + + CopyMem (CopyTo, CopyFrom, IntBytes); + + 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 = MmioRead16 ( + 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 = ReadData; + // Read the first few to get Read buffer aligned + TempRead = MmioRead16 ( + CREATE_NOR_ADDRESS ( + Instance->DeviceBaseAddress, + CREATE_BYTE_OFFSET (TargetOffsetinBytes/sizeof (FLASH_DATA)) + ) + ); + CopyFrom = &TempRead; + + CopyMem (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 +EFIAPI +NorFlashInitMmioOps ( + VOID + ) +{ + mMmioOps = GetMmioOperations16 (FixedPcdGetBool (PcdIfcBigEndian)); + return EFI_SUCCESS; +} + +EFI_STATUS +NorFlashPlatformGetDevices ( + OUT NorFlashDescription **NorFlashDevices, + OUT UINT32 *Count + ) +{ + // This is the function to be called, before using + 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..e0370b9 --- /dev/null +++ b/Silicon/NXP/Library/NorFlashLib/NorFlashLib.inf @@ -0,0 +1,43 @@ +# @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 + CONSTRUCTOR = NorFlashInitMmioOps + +[Sources.common] + CfiNorFlashLib.c + NorFlashLib.c + +[LibraryClasses] + ArmLib + IoAccessLib + 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
