GitBucket
Newer
/*
* Copyright (c) 2006-2016, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Driver_Storage.h"
#include "cmsis_nvic.h"
#include "MK64F12.h"
#if defined(MCU_MEM_MAP_VERSION) && ((MCU_MEM_MAP_VERSION > 0x0200u) || ((MCU_MEM_MAP_VERSION == 0x0200u) && (MCU_MEM_MAP_VERSION_MINOR >= 0x0008u)))
#define USING_KSDK2 1
#endif
#ifndef USING_KSDK2
#include "device/MK64F12/MK64F12_ftfe.h"
#else
#include "fsl_flash.h"
#endif
#include <string.h>
/* Redefine this macro to a printf equivalent to print trace */
#define tr_debug(...)
#ifdef USING_KSDK2
/*!
* @name Misc utility defines
* @{
*/
#ifndef ALIGN_DOWN
#define ALIGN_DOWN(x, a) ((x) & (uint32_t)(-((int32_t)(a))))
#endif
#ifndef ALIGN_UP
#define ALIGN_UP(x, a) (-((int32_t)((uint32_t)(-((int32_t)(x))) & (uint32_t)(-((int32_t)(a))))))
#endif
#define BYTES_JOIN_TO_WORD_1_3(x, y) ((((uint32_t)(x)&0xFFU) << 24) | ((uint32_t)(y)&0xFFFFFFU))
#define BYTES_JOIN_TO_WORD_2_2(x, y) ((((uint32_t)(x)&0xFFFFU) << 16) | ((uint32_t)(y)&0xFFFFU))
#define BYTES_JOIN_TO_WORD_3_1(x, y) ((((uint32_t)(x)&0xFFFFFFU) << 8) | ((uint32_t)(y)&0xFFU))
#define BYTES_JOIN_TO_WORD_1_1_2(x, y, z) \
((((uint32_t)(x)&0xFFU) << 24) | (((uint32_t)(y)&0xFFU) << 16) | ((uint32_t)(z)&0xFFFFU))
#define BYTES_JOIN_TO_WORD_1_2_1(x, y, z) \
((((uint32_t)(x)&0xFFU) << 24) | (((uint32_t)(y)&0xFFFFU) << 8) | ((uint32_t)(z)&0xFFU))
#define BYTES_JOIN_TO_WORD_2_1_1(x, y, z) \
((((uint32_t)(x)&0xFFFFU) << 16) | (((uint32_t)(y)&0xFFU) << 8) | ((uint32_t)(z)&0xFFU))
#define BYTES_JOIN_TO_WORD_1_1_1_1(x, y, z, w) \
((((uint32_t)(x)&0xFFU) << 24) | (((uint32_t)(y)&0xFFU) << 16) | (((uint32_t)(z)&0xFFU) << 8) | \
((uint32_t)(w)&0xFFU))
/*@}*/
/*!
* @name Common flash register info defines
* @{
*/
#if defined(FTFA)
#define FTFx FTFA
#define FTFx_BASE FTFA_BASE
#define FTFx_FSTAT_CCIF_MASK FTFA_FSTAT_CCIF_MASK
#define FTFx_FSTAT_RDCOLERR_MASK FTFA_FSTAT_RDCOLERR_MASK
#define FTFx_FSTAT_ACCERR_MASK FTFA_FSTAT_ACCERR_MASK
#define FTFx_FSTAT_FPVIOL_MASK FTFA_FSTAT_FPVIOL_MASK
#define FTFx_FSTAT_MGSTAT0_MASK FTFA_FSTAT_MGSTAT0_MASK
#define FTFx_FSEC_SEC_MASK FTFA_FSEC_SEC_MASK
#define FTFx_FSEC_KEYEN_MASK FTFA_FSEC_KEYEN_MASK
#define FTFx_FCNFG_CCIF_MASK FTFA_FCNFG_CCIE_MASK
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_RAM) && FSL_FEATURE_FLASH_HAS_FLEX_RAM
#define FTFx_FCNFG_RAMRDY_MASK FTFA_FCNFG_RAMRDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_RAM */
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_NVM) && FSL_FEATURE_FLASH_HAS_FLEX_NVM
#define FTFx_FCNFG_EEERDY_MASK FTFA_FCNFG_EEERDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_NVM */
#elif defined(FTFE)
#define FTFx FTFE
#define FTFx_BASE FTFE_BASE
#define FTFx_FSTAT_CCIF_MASK FTFE_FSTAT_CCIF_MASK
#define FTFx_FSTAT_RDCOLERR_MASK FTFE_FSTAT_RDCOLERR_MASK
#define FTFx_FSTAT_ACCERR_MASK FTFE_FSTAT_ACCERR_MASK
#define FTFx_FSTAT_FPVIOL_MASK FTFE_FSTAT_FPVIOL_MASK
#define FTFx_FSTAT_MGSTAT0_MASK FTFE_FSTAT_MGSTAT0_MASK
#define FTFx_FSEC_SEC_MASK FTFE_FSEC_SEC_MASK
#define FTFx_FSEC_KEYEN_MASK FTFE_FSEC_KEYEN_MASK
#define FTFx_FCNFG_CCIF_MASK FTFE_FCNFG_CCIE_MASK
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_RAM) && FSL_FEATURE_FLASH_HAS_FLEX_RAM
#define FTFx_FCNFG_RAMRDY_MASK FTFE_FCNFG_RAMRDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_RAM */
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_NVM) && FSL_FEATURE_FLASH_HAS_FLEX_NVM
#define FTFx_FCNFG_EEERDY_MASK FTFE_FCNFG_EEERDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_NVM */
#elif defined(FTFL)
#define FTFx FTFL
#define FTFx_BASE FTFL_BASE
#define FTFx_FSTAT_CCIF_MASK FTFL_FSTAT_CCIF_MASK
#define FTFx_FSTAT_RDCOLERR_MASK FTFL_FSTAT_RDCOLERR_MASK
#define FTFx_FSTAT_ACCERR_MASK FTFL_FSTAT_ACCERR_MASK
#define FTFx_FSTAT_FPVIOL_MASK FTFL_FSTAT_FPVIOL_MASK
#define FTFx_FSTAT_MGSTAT0_MASK FTFL_FSTAT_MGSTAT0_MASK
#define FTFx_FSEC_SEC_MASK FTFL_FSEC_SEC_MASK
#define FTFx_FSEC_KEYEN_MASK FTFL_FSEC_KEYEN_MASK
#define FTFx_FCNFG_CCIF_MASK FTFL_FCNFG_CCIE_MASK
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_RAM) && FSL_FEATURE_FLASH_HAS_FLEX_RAM
#define FTFx_FCNFG_RAMRDY_MASK FTFL_FCNFG_RAMRDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_RAM */
#if defined(FSL_FEATURE_FLASH_HAS_FLEX_NVM) && FSL_FEATURE_FLASH_HAS_FLEX_NVM
#define FTFx_FCNFG_EEERDY_MASK FTFL_FCNFG_EEERDY_MASK
#endif /* FSL_FEATURE_FLASH_HAS_FLEX_NVM */
#else
#error "Unknown flash controller"
#endif
/*@}*/
/*! @brief Access to FTFx->FCCOB */
extern volatile uint32_t *const kFCCOBx;
#endif /* #ifdef USING_KSDK2 */
#ifdef USING_KSDK2
#define ERASE_UNIT (FSL_FEATURE_FLASH_PFLASH_BLOCK_SECTOR_SIZE)
#define BLOCK1_START_ADDR (FSL_FEATURE_FLASH_PFLASH_BLOCK_SIZE)
#define BLOCK1_SIZE (FSL_FEATURE_FLASH_PFLASH_BLOCK_SIZE)
#define PROGRAM_UNIT (FSL_FEATURE_FLASH_PFLASH_BLOCK_WRITE_UNIT_SIZE)
#define OPTIMAL_PROGRAM_UNIT (1024UL)
#define PROGRAM_PHRASE_SIZEOF_INLINE_DATA (8)
#define SIZEOF_DOUBLE_PHRASE (FSL_FEATURE_FLASH_PFLASH_SECTION_CMD_ADDRESS_ALIGMENT)
#else /* ifdef USING_KSDK2 */
#define ERASE_UNIT (4096)
#define BLOCK1_START_ADDR (0x80000UL)
#define BLOCK1_SIZE (0x80000UL)
#define PROGRAM_UNIT (8UL)
#define OPTIMAL_PROGRAM_UNIT (1024UL)
#define PROGRAM_PHRASE_SIZEOF_INLINE_DATA (8)
#define SIZEOF_DOUBLE_PHRASE (16)
#endif /* #ifdef USING_KSDK2 */
/* While the K64F flash controller is capable of launching operations asynchronously and
* allowing program execution to continue while an erase/program is active, it
* doesn't allow simultaneous read accesses while and erase/program is active on
* the same block of flash.
*
* Read/fetch accesses can originate arbitrarily as a result of program
* execution. This means that code which operates on flash should not reside in
* flash; or at least it should not reside in the same bank of flash as it is
* operating upon. The only way to ensure that application code and flash driver
* are residing on separate banks of flash is to reserve bank-0 (or BLOCK0) for
* the application and bank-1 (BLOCK1) for the driver--this also happens to be
* the default setting.
*
* But it is quite likely that this default will be over-ridden by the use of
* config options depending upon the actual application. If we don't have a
* clean separation between the application and the space managed by this
* driver, then we need to enforce the following:
*
* - Force synchronous mode of execution in the storage_driver.
* - Disable interrupts during erase/program operations.
* - Ensure all code and data structures used in the storage driver execute
* out of RAM. Refer to __RAMFUNC (below) which allows for this.
*
* It is difficult to determine the application's span of internal-flash at
* compile time. Therefore we assume that STORAGE_START_ADDR is the
* boundary between application and this driver. When this boundary is set to
* lie at BLOCK1_START_ADDR, there is no possibility of read-while-write run-
* time errors.
*
* In the following, caps.asynchronous_ops is defined to be 1 if and only if
* asynchronous operation mode is requested and there doesn't exist the
* possibility of concurrent reads.
*/
#if (defined(STORAGE_START_ADDR) && (STORAGE_START_ADDR != BLOCK1_START_ADDR))
#define EXISTS_POSSIBILITY_OF_CONCURRENT_READ 1
#else
#define EXISTS_POSSIBILITY_OF_CONCURRENT_READ 0
#endif
/* Define '__RAMFUNC' as an attribute to mark a function as residing in RAM.
* Use of __RAMFUNC puts a function in the .data section--i.e. the
* initialized data section. This will be copied into RAM automatically by the
* startup sequence. */
#ifndef __RAMFUNC
#if defined(__GNUC__) || defined(__clang__) // GCC and llvm/clang
#define __RAMFUNC __attribute__ ((section (".data#"), noinline)) /* The '#' following ".data" needs a bit of
* explanation. Without it, we are liable to get the following warning 'Warning: ignoring
* changed section attributes for .data'. This is because __attribute__((section(".data")))
* generates the following assembly:
*
* .section .data,"ax",%progbits
*
* But .data doesn't need the 'x' (execute) attribute bit. To remove the warning, we specify
* the attribute with a '#' at the tail, which emits:
*
* .section .data#,"ax",%progbits
*
* Note that '#' (in the above) acts like a comment-start, and masks the additional
* attributes which don't apply to '.data'.
*/
#elif defined (__CC_ARM)
#define __RAMFUNC __attribute__ ((section(".ramfunc"), noinline))
#elif defined ( __ICCARM__ )
#define __RAMFUNC __ramfunc
#else // unknown compiler
#error "This compiler is not yet supported. If you can contribute support for defining a function to be RAM resident, please provide a definition for __RAMFUNC"
#endif
#endif /* #ifndef __RAMFUNC */
/*
* forward declarations
*/
static int32_t getBlock(uint64_t addr, ARM_STORAGE_BLOCK *blockP);
static int32_t nextBlock(const ARM_STORAGE_BLOCK* prevP, ARM_STORAGE_BLOCK *nextP);
/*
* Global state for the driver.
*/
struct mtd_k64f_data {
ARM_Storage_Callback_t commandCompletionCallback;
bool initialized;
ARM_POWER_STATE powerState;
ARM_STORAGE_OPERATION currentCommand;
uint64_t currentOperatingStorageAddress;
size_t sizeofCurrentOperation;
size_t amountLeftToOperate;
const uint8_t *currentOperatingData;
} mtd_k64f_data;
/*
* Static configuration.
*/
static const ARM_STORAGE_BLOCK blockTable[] = {
{
/**< This is the start address of the flash block. */
#ifdef STORAGE_START_ADDR
.addr = STORAGE_START_ADDR,
#else
.addr = BLOCK1_START_ADDR,
#endif
/**< This is the size of the flash block, in units of bytes.
* Together with addr, it describes a range [addr, addr+size). */
#ifdef STORAGE_SIZE
.size = STORAGE_SIZE,
#else
.size = BLOCK1_SIZE,
#endif
.attributes = { /**< Attributes for this block. */
.erasable = 1,
.programmable = 1,
.executable = 1,
.protectable = 1,
.erase_unit = ERASE_UNIT,
.protection_unit = BLOCK1_SIZE / 32,
}
}
};
static const ARM_DRIVER_VERSION version = {
.api = ARM_STORAGE_API_VERSION,
.drv = ARM_DRIVER_VERSION_MAJOR_MINOR(1,00)
};
#if ((!defined(STORAGE_CONFIG_HARDWARE_MTD_K64F_ASYNC_OPS) || STORAGE_CONFIG_HARDWARE_MTD_K64F_ASYNC_OPS) && \
!EXISTS_POSSIBILITY_OF_CONCURRENT_READ)
#define ASYNC_OPS 1
#else
#define ASYNC_OPS 0
#endif
static const ARM_STORAGE_CAPABILITIES caps = {
/**< Signal Flash Ready event. In other words, can APIs like initialize,
* read, erase, program, etc. operate in asynchronous mode?
* Setting this bit to 1 means that the driver is capable of launching
* asynchronous operations; command completion is signaled by the
* generation of an event or the invocation of a completion callback
* (depending on how the flash controller has been initialized). If set to
* 1, drivers may still complete asynchronous operations synchronously as
* necessary--in which case they return a positive error code to indicate
* synchronous completion. */
.asynchronous_ops = ASYNC_OPS,
/* Enable chip-erase functionality if we own all of block-1. */
#if ((!defined (STORAGE_START_ADDR) || (STORAGE_START_ADDR == BLOCK1_START_ADDR)) && \
(!defined (STORAGE_SIZE) || (STORAGE_SIZE == BLOCK1_SIZE)))
.erase_all = 1, /**< Supports EraseChip operation. */
#else
.erase_all = 0, /**< Supports EraseChip operation. */
#endif
};
static const ARM_STORAGE_INFO info = {
#ifdef STORAGE_SIZE
.total_storage = STORAGE_SIZE, /**< Total available storage, in units of octets. */
#else
.total_storage = BLOCK1_SIZE, /**< Total available storage, in units of octets. By default, BLOCK0 is reserved to hold program code. */
#endif
.program_unit = PROGRAM_UNIT,
.optimal_program_unit = OPTIMAL_PROGRAM_UNIT,
.program_cycles = ARM_STORAGE_PROGRAM_CYCLES_INFINITE, /**< A measure of endurance for reprogramming.
* Use ARM_STOR_PROGRAM_CYCLES_INFINITE for infinite or unknown endurance. */
.erased_value = 0x1, /**< Contents of erased memory (1 to indicate erased octets with state 0xFF). */
.memory_mapped = 1,
.programmability = ARM_STORAGE_PROGRAMMABILITY_ERASABLE, /**< A value of type enum ARM_STOR_PROGRAMMABILITY. */
.retention_level = ARM_RETENTION_NVM,
.security = {
.acls = 0, /**< against internal software attacks using ACLs. */
.rollback_protection = 0, /**< roll-back protection. */
.tamper_proof = 0, /**< tamper-proof memory (will be deleted on tamper-attempts using board level or chip level sensors). */
.internal_flash = 1, /**< Internal flash. */
.software_attacks = 0,
.board_level_attacks = 0,
.chip_level_attacks = 0,
.side_channel_attacks = 0,
}
};
/**
* This is the command code written into the first FCCOB register, FCCOB0.
*/
enum FlashCommandOps {
RD1SEC = (uint8_t)0x01, /* read 1s section */
PGM8 = (uint8_t)0x07, /* program phrase */
ERSBLK = (uint8_t)0x08, /* erase block */
ERSSCR = (uint8_t)0x09, /* erase flash sector */
PGMSEC = (uint8_t)0x0B, /* program section */
SETRAM = (uint8_t)0x81, /* Set FlexRAM. (unused for now) */
};
/**
* Read out the CCIF (Command Complete Interrupt Flag) to ensure all previous
* operations have completed.
*/
static inline bool controllerCurrentlyBusy(void)
{
#ifdef USING_KSDK2
return ((FTFx->FSTAT & FTFx_FSTAT_CCIF_MASK) == 0);
#else
return (BR_FTFE_FSTAT_CCIF(FTFE) == 0);
#endif
}
static inline bool failedWithAccessError(void)
{
#ifdef USING_KSDK2
/* Get flash status register value */
uint8_t registerValue = FTFx->FSTAT;
/* checking access error */
return registerValue & FTFx_FSTAT_ACCERR_MASK;
#else /* ifdef USING_KSDK2 */
return BR_FTFE_FSTAT_ACCERR(FTFE);
#endif /* ifdef USING_KSDK2 */
}
static inline bool failedWithProtectionError()
{
#ifdef USING_KSDK2
/* Get flash status register value */
uint8_t registerValue = FTFx->FSTAT;
/* checking protection error */
return registerValue & FTFx_FSTAT_FPVIOL_MASK;
#else /* ifdef USING_KSDK2 */
return BR_FTFE_FSTAT_FPVIOL(FTFE);
#endif /* ifdef USING_KSDK2 */
}
static inline bool failedWithRunTimeError()
{
#ifdef USING_KSDK2
/* Get flash status register value */
uint8_t registerValue = FTFx->FSTAT;
/* checking MGSTAT0 non-correctable error */
return registerValue & FTFx_FSTAT_MGSTAT0_MASK;
#else /* ifdef USING_KSDK2 */
return BR_FTFE_FSTAT_MGSTAT0(FTFE);
#endif /* ifdef USING_KSDK2 */
}
static inline void clearAccessError(void)
{
#ifdef USING_KSDK2
FTFx->FSTAT |= FTFx_FSTAT_ACCERR_MASK;
#else
BW_FTFE_FSTAT_ACCERR(FTFE, 1);
#endif
}
static inline void clearProtectionError(void)
{
#ifdef USING_KSDK2
FTFx->FSTAT |= FTFx_FSTAT_FPVIOL_MASK;
#else
BW_FTFE_FSTAT_FPVIOL(FTFE, 1);
#endif
}
/**
* @brief Clear the error bits before launching a command.
*
* The ACCERR error bit indicates an illegal access has occurred to an FTFE
* resource caused by a violation of the command write sequence or issuing an
* illegal FTFE command. While ACCERR is set, the CCIF flag cannot be cleared to
* launch a command. The ACCERR bit is cleared by writing a 1 to it.
*
* The FPVIOL error bit indicates an attempt was made to program or erase an
* address in a protected area of program flash or data flash memory during a
* command write sequence or a write was attempted to a protected area of the
* FlexRAM while enabled for EEPROM. While FPVIOL is set, the CCIF flag cannot
* be cleared to launch a command. The FPVIOL bit is cleared by writing a 1 to
* it.
*/
static inline void clearErrorStatusBits()
{
if (failedWithAccessError()) {
clearAccessError();
}
if (failedWithProtectionError()) {
clearProtectionError();
}
}
/* The following functions are only needed if using interrupt-driven operation. */
#if ASYNC_OPS
static inline void enableCommandCompletionInterrupt(void)
{
#ifdef USING_KSDK2
FTFx->FCNFG |= FTFE_FCNFG_CCIE_MASK;
#else
BW_FTFE_FCNFG_CCIE((uintptr_t)FTFE, 1); /* enable interrupt to detect CCIE being set. */
#endif
}
static inline void disbleCommandCompletionInterrupt(void)
{
#ifdef USING_KSDK2
FTFx->FCNFG &= ~FTFE_FCNFG_CCIE_MASK;
#else
BW_FTFE_FCNFG_CCIE((uintptr_t)FTFE, 0); /* disable command completion interrupt. */
#endif
}
static inline bool commandCompletionInterruptEnabled(void)
{
#ifdef USING_KSDK2
return ((FTFx->FCNFG & FTFE_FCNFG_CCIE_MASK) != 0);
#else
return (BR_FTFE_FCNFG_CCIE((uintptr_t)FTFE) != 0);
#endif
}
/**
* Once all relevant command parameters have been loaded, the user launches the
* command by clearing the FSTAT[CCIF] bit by writing a '1' to it. The CCIF flag
* remains zero until the FTFE command completes.
*/
static inline void launchCommand(void)
{
#ifdef USING_KSDK2
FTFx->FSTAT = FTFx_FSTAT_CCIF_MASK;
#else
BW_FTFE_FSTAT_CCIF(FTFE, 1);
#endif
}
#else /* #if !ASYNC_OPS */
#if EXISTS_POSSIBILITY_OF_CONCURRENT_READ
/* This function needs to execute from RAM to avoid read-while-write errors. */
__RAMFUNC
#endif
static void launchCommandAndWaitForCompletion()
{
// It contains the inlined equivalent of the following code snippet:
// launchCommand();
// while (controllerCurrentlyBusy()) {
// /* Spin waiting for the command execution to complete. */
// }
#ifdef USING_KSDK2
FTFx->FSTAT = FTFx_FSTAT_CCIF_MASK; /* launchcommand() */
while ((FTFx->FSTAT & FTFx_FSTAT_CCIF_MASK) == 0) {
/* Spin waiting for the command execution to complete. */
}
#else
BW_FTFE_FSTAT_CCIF(FTFE, 1); /* launchCommand() */
while (BR_FTFE_FSTAT_CCIF(FTFE) == 0) {
/* Spin waiting for the command execution to complete. */
}
#endif
}
#endif /* #if !ASYNC_OPS */
#ifndef USING_KSDK2
static inline void setupAddressInCCOB123(uint64_t addr)
{
BW_FTFE_FCCOB1_CCOBn((uintptr_t)FTFE, (addr >> 16) & 0xFFUL); /* bits [23:16] of the address. */
BW_FTFE_FCCOB2_CCOBn((uintptr_t)FTFE, (addr >> 8) & 0xFFUL); /* bits [15:8] of the address. */
BW_FTFE_FCCOB3_CCOBn((uintptr_t)FTFE, (addr >> 0) & 0xFFUL); /* bits [7:0] of the address. */
}
#endif /* ifndef USING_KSDK2 */
static inline void setupRead1sSection(uint64_t addr, size_t cnt)
{
#ifdef USING_KSDK2
kFCCOBx[0] = BYTES_JOIN_TO_WORD_1_3(RD1SEC, addr);
kFCCOBx[1] = BYTES_JOIN_TO_WORD_2_1_1(cnt >> 4, 0 /* normal read level */, 0);
#else
BW_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE, RD1SEC);
setupAddressInCCOB123(addr);
BW_FTFE_FCCOB4_CCOBn((uintptr_t)FTFE, ((cnt >> 4) >> 8) & 0xFFUL); /* bits [15:8] of cnt in units of 128-bits. */
BW_FTFE_FCCOB5_CCOBn((uintptr_t)FTFE, ((cnt >> 4) >> 0) & 0xFFUL); /* bits [7:0] of cnt in units of 128-bits. */
BW_FTFE_FCCOB6_CCOBn((uintptr_t)FTFE, 0); /* use normal read level for 1s. */
#endif
}
static inline bool currentCommandByteIsRD1SEC(void)
{
#ifdef USING_KSDK2
return ((kFCCOBx[0] >> 24) == RD1SEC);
#else
return (BR_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE) == RD1SEC);
#endif
}
static inline bool currentCommandSetupIsAnEraseCheck(const struct mtd_k64f_data *context)
{
return ((context->currentCommand == ARM_STORAGE_OPERATION_ERASE) && currentCommandByteIsRD1SEC());
}
static inline void setupEraseSector(uint64_t addr)
{
#ifdef USING_KSDK2
kFCCOBx[0] = BYTES_JOIN_TO_WORD_1_3(ERSSCR, addr);
#else
BW_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE, ERSSCR);
setupAddressInCCOB123(addr);
#endif
}
static inline void setupEraseBlock(uint64_t addr)
{
#ifdef USING_KSDK2
kFCCOBx[0] = BYTES_JOIN_TO_WORD_1_3(ERSBLK, addr);
#else
BW_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE, ERSBLK);
setupAddressInCCOB123(addr);
#endif
}
static inline void setup8ByteWrite(uint64_t addr, const void *data)
{
/* Program FCCOB to load the required command parameters. */
#ifdef USING_KSDK2
kFCCOBx[0] = BYTES_JOIN_TO_WORD_1_3(PGM8, addr);
/* Program 8 bytes of data into FCCOB(4..11)_CCOBn */
kFCCOBx[1] = ((const uint32_t *)data)[0];
kFCCOBx[2] = ((const uint32_t *)data)[1];
#else /* ifdef USING_KSDK2 */
BW_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE, PGM8);
setupAddressInCCOB123(addr);
BW_FTFE_FCCOB4_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[3]); /* byte 3 of program value. */
BW_FTFE_FCCOB5_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[2]); /* byte 2 of program value. */
BW_FTFE_FCCOB6_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[1]); /* byte 1 of program value. */
BW_FTFE_FCCOB7_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[0]); /* byte 0 of program value. */
BW_FTFE_FCCOB8_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[7]); /* byte 7 of program value. */
BW_FTFE_FCCOB9_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[6]); /* byte 6 of program value. */
BW_FTFE_FCCOBA_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[5]); /* byte 5 of program value. */
BW_FTFE_FCCOBB_CCOBn((uintptr_t)FTFE, ((const uint8_t *)data)[4]); /* byte 4 of program value. */
#endif /* ifdef USING_KSDK2 */
}
static inline void setupProgramSection(uint64_t addr, const void *data, size_t cnt)
{
#ifdef USING_KSDK2
static const uintptr_t FlexRAMBase = FSL_FEATURE_FLASH_FLEX_RAM_START_ADDRESS;
memcpy((void *)FlexRAMBase, (const uint8_t *)data, cnt);
kFCCOBx[0] = BYTES_JOIN_TO_WORD_1_3(PGMSEC, addr);
kFCCOBx[1] = BYTES_JOIN_TO_WORD_2_2(cnt >> 4, 0xFFFFU);
#else /* ifdef USING_KSDK2 */
static const uintptr_t FlexRAMBase = 0x14000000;
memcpy((void *)FlexRAMBase, (const uint8_t *)data, cnt);
BW_FTFE_FCCOB0_CCOBn((uintptr_t)FTFE, PGMSEC);
setupAddressInCCOB123(addr);
BW_FTFE_FCCOB4_CCOBn((uintptr_t)FTFE, ((((uint32_t)(cnt >> 4)) & (0x0000FF00)) >> 8)); /* number of 128-bits to program [15:8] */
BW_FTFE_FCCOB5_CCOBn((uintptr_t)FTFE, (((uint32_t)(cnt >> 4)) & (0x000000FF))); /* number of 128-bits to program [7:0] */
#endif /* ifdef USING_KSDK2 */
}
/**
* Compute the size of the largest 'program-section' operation which is
* possible for the range [addr, addr+size) starting from addr. It is assumed
* that 'addr' is aligned to a double-phrase boundary (see \ref
* SIZEOF_DOUBLE_PHRASE)--if not, then only a single phrase (8-bytes) write is possible.
*/
static inline size_t sizeofLargestProgramSection(uint64_t addr, size_t size)
{
/* ensure 'size' is aligned to a double-phrase boundary */
if ((size % SIZEOF_DOUBLE_PHRASE) == PROGRAM_PHRASE_SIZEOF_INLINE_DATA) {
size -= PROGRAM_PHRASE_SIZEOF_INLINE_DATA;
}
/* ensure 'size' isn't larger than OPTIMAL_PROGRAM_UNIT */
if (size > OPTIMAL_PROGRAM_UNIT) {
size = OPTIMAL_PROGRAM_UNIT;
}
/* ensure that the operation doesn't cross an erase boundary */
size_t amountLeftInEraseUnit = ERASE_UNIT - (size_t)(addr % ERASE_UNIT);
if (size > amountLeftInEraseUnit) {
size = amountLeftInEraseUnit;
}
return size;
}
/**
* Advance the state machine for program-data. This function is called only if
* amountLeftToOperate is non-zero.
*/
static inline void setupNextProgramData(struct mtd_k64f_data *context)
{
if ((context->amountLeftToOperate == PROGRAM_PHRASE_SIZEOF_INLINE_DATA) ||
((context->currentOperatingStorageAddress % SIZEOF_DOUBLE_PHRASE) == PROGRAM_PHRASE_SIZEOF_INLINE_DATA)) {
setup8ByteWrite(context->currentOperatingStorageAddress, context->currentOperatingData);
tr_debug("setupNextProgramData: W8, [%lu]", (uint32_t)context->currentOperatingStorageAddress);
context->amountLeftToOperate -= PROGRAM_PHRASE_SIZEOF_INLINE_DATA;
context->currentOperatingStorageAddress += PROGRAM_PHRASE_SIZEOF_INLINE_DATA;
context->currentOperatingData += PROGRAM_PHRASE_SIZEOF_INLINE_DATA;
} else {
size_t amount = sizeofLargestProgramSection(context->currentOperatingStorageAddress, context->amountLeftToOperate);
setupProgramSection(context->currentOperatingStorageAddress, context->currentOperatingData, amount);
tr_debug("setupNextProgramData: W%u, [%lu]", amount, (uint32_t)context->currentOperatingStorageAddress);
context->amountLeftToOperate -= amount;
context->currentOperatingStorageAddress += amount;
context->currentOperatingData += amount;
}
}
/* Setup a command to determine if erase is needed for the range
* [context->currentOperatingStorageAddress, context->currentOperatingStorageAddress + ERASE_UNIT).
* If any byte within the range isn't 0xFF, this command results in a run-time
* error.
*
* Upon launch, if any byte within the given range isn't 0xFF then this command
* will terminate in a run-time error.
*/
static inline void setupNextEraseCheck(const struct mtd_k64f_data *context)
{
setupRead1sSection(context->currentOperatingStorageAddress, ERASE_UNIT); /* setup check for erased */
}
static inline void progressEraseContextByEraseUnit(struct mtd_k64f_data *context)
{
context->amountLeftToOperate -= ERASE_UNIT;
context->currentOperatingStorageAddress += ERASE_UNIT;
}
/**
* Advance the state machine for erase. This function is called only if
* amountLeftToOperate is non-zero.
*/
static inline void setupNextErase(struct mtd_k64f_data *context)
{
setupEraseSector(context->currentOperatingStorageAddress); /* Program FCCOB to load the required command parameters. */
progressEraseContextByEraseUnit(context);
}
static int32_t executeCommand(struct mtd_k64f_data *context)
{
tr_debug("executeCommand: top");
#if ASYNC_OPS
/* Asynchronous operation */
(void)context; /* avoid compiler warning about un-used variables */
launchCommand();
/* At this point, The FTFE reads the command code and performs a series of
* parameter checks and protection checks, if applicable, which are unique
* to each command. */
/* Spin waiting for the command execution to begin. */
while (!controllerCurrentlyBusy() && !failedWithAccessError() && !failedWithProtectionError());
if (failedWithAccessError() || failedWithProtectionError()) {
clearErrorStatusBits();
return ARM_DRIVER_ERROR_PARAMETER;
}
enableCommandCompletionInterrupt();
tr_debug("executeCommand: async. return");
return ARM_DRIVER_OK; /* signal asynchronous completion. An interrupt will signal completion later. */
#else /* #if ASYNC_OPS */
/* Synchronous operation. This is the common case. */
while (1) {
tr_debug("executeCommand: synchronous iteration");
#if EXISTS_POSSIBILITY_OF_CONCURRENT_READ
__disable_irq();
#endif
launchCommandAndWaitForCompletion();
#if EXISTS_POSSIBILITY_OF_CONCURRENT_READ
__enable_irq();
#endif
/* Execution may result in failure. Check for errors */
if (failedWithAccessError() || failedWithProtectionError()) {
clearErrorStatusBits();
return ARM_DRIVER_ERROR_PARAMETER;
}
if (failedWithRunTimeError()) {
/* filter away run-time errors which may legitimately arise from an erase-check operation. */
if (!currentCommandSetupIsAnEraseCheck(context)) {
return ARM_STORAGE_ERROR_RUNTIME_OR_INTEGRITY_FAILURE;
}
}
/* signal synchronous completion. */
switch (context->currentCommand) {
case ARM_STORAGE_OPERATION_PROGRAM_DATA:
if (context->amountLeftToOperate == 0) {
return context->sizeofCurrentOperation;
}
/* start the successive program operation */
setupNextProgramData(context);
/* continue on to the next iteration of the parent loop */
break;
case ARM_STORAGE_OPERATION_ERASE:
if (currentCommandSetupIsAnEraseCheck(context)) {
if (failedWithRunTimeError()) {
/* a run-time failure from an erase-check indicates at an erase operation is necessary */
setupNextErase(context);
/* continue on to the next iteration of the parent loop */
break;
} else {
/* erase can be skipped since this sector is already erased. */
tr_debug("fast forward erase");
progressEraseContextByEraseUnit(context);
}
}
if (context->amountLeftToOperate == 0) {
return context->sizeofCurrentOperation;
}
setupNextEraseCheck(context); /* start the erase check on the successive erase sector */
/* continue on to the next iteration of the parent loop */
break;
default:
return 1;
}
}
#endif /* #ifdef ASYNC_OPS */
}
#if ASYNC_OPS
static inline void launchCommandFromIRQ(const struct mtd_k64f_data *context)
{
launchCommand();
while (!controllerCurrentlyBusy() && !failedWithAccessError() && !failedWithProtectionError());
if (failedWithAccessError() || failedWithProtectionError()) {
clearErrorStatusBits();
if (context->commandCompletionCallback) {
tr_debug("irq: invoking callback with error");
context->commandCompletionCallback(ARM_DRIVER_ERROR_PARAMETER, context->currentCommand);
}
return;
}
enableCommandCompletionInterrupt();
}
static void ftfe_ccie_irq_handler(void)
{
disbleCommandCompletionInterrupt();
struct mtd_k64f_data *context = &mtd_k64f_data;
/* check for errors */
if (failedWithAccessError() || failedWithProtectionError()) {
clearErrorStatusBits();
if (context->commandCompletionCallback) {
context->commandCompletionCallback(ARM_DRIVER_ERROR_PARAMETER, context->currentCommand);
}
return;
}
if (failedWithRunTimeError()) {
/* filter away run-time errors which may legitimately arise from an erase-check operation. */
if (!currentCommandSetupIsAnEraseCheck(context)) {
if (context->commandCompletionCallback) {
context->commandCompletionCallback(ARM_STORAGE_ERROR_RUNTIME_OR_INTEGRITY_FAILURE, context->currentCommand);
}
return;
}
}
switch (context->currentCommand) {
case ARM_STORAGE_OPERATION_PROGRAM_DATA:
if (context->amountLeftToOperate == 0) {
if (context->commandCompletionCallback) {
tr_debug("irq: [PROGRAM] invoking callback");
context->commandCompletionCallback(context->sizeofCurrentOperation, ARM_STORAGE_OPERATION_PROGRAM_DATA);
}
return;
}
/* start the successive program operation */
setupNextProgramData(context);
launchCommandFromIRQ(context);
break;
case ARM_STORAGE_OPERATION_ERASE:
if (currentCommandSetupIsAnEraseCheck(context)) {
if (failedWithRunTimeError()) {
/* a run-time failure from an erase-check indicates at an erase operation is necessary */
setupNextErase(context);
launchCommandFromIRQ(context);
break;
} else {
/* erase can be skipped since this sector is already erased. */
tr_debug("fast forward erase");
progressEraseContextByEraseUnit(context);
}
}
if (context->amountLeftToOperate == 0) {
if (context->commandCompletionCallback) {
tr_debug("irq: [ERASE] invoking callback");
context->commandCompletionCallback(context->sizeofCurrentOperation, ARM_STORAGE_OPERATION_ERASE);
}
return;
}
setupNextEraseCheck(context); /* start the erase check on the successive erase sector */
launchCommandFromIRQ(context);
break;
default:
if (context->commandCompletionCallback) {
tr_debug("irq: [default] invoking callback");
context->commandCompletionCallback(ARM_DRIVER_OK, context->currentCommand);
}
break;
}
}
#endif /* #if ASYNC_OPS */
/**
* This is a helper function which can be used to do arbitrary sanity checking
* on a range.
*
* It applies the 'check' function to every block in a given range. If any of
* the check() calls return failure (i.e. something other ARM_DRIVER_OK),
* validation terminates. Otherwise an ARM_DRIVER_OK is returned.
*/
static int32_t checkForEachBlockInRange(uint64_t startAddr, uint32_t size, int32_t (*check)(const ARM_STORAGE_BLOCK *block))
{
uint64_t addrBeingValidated = startAddr;
ARM_STORAGE_BLOCK block;
if (getBlock(addrBeingValidated, &block) != ARM_DRIVER_OK) {
return ARM_DRIVER_ERROR_PARAMETER;
}
while (addrBeingValidated < (startAddr + size)) {
int32_t rc;
if ((rc = check(&block)) != ARM_DRIVER_OK) {
return rc;
}
/* move on to the following block */
if (nextBlock(&block, &block) != ARM_DRIVER_OK) {
break;
}
addrBeingValidated = block.addr;
}
return ARM_DRIVER_OK;
}
static int32_t blockIsProgrammable(const ARM_STORAGE_BLOCK *blockP)
{
if (!blockP->attributes.programmable) {
return ARM_STORAGE_ERROR_NOT_PROGRAMMABLE;
}
return ARM_DRIVER_OK;
}
static int32_t blockIsErasable(const ARM_STORAGE_BLOCK *blockP)
{
if (!blockP->attributes.erasable) {
return ARM_STORAGE_ERROR_NOT_ERASABLE;
}
return ARM_DRIVER_OK;
}
static ARM_DRIVER_VERSION getVersion(void)
{
return version;
}
static ARM_STORAGE_CAPABILITIES getCapabilities(void)
{
return caps;
}
static int32_t initialize(ARM_Storage_Callback_t callback)
{
tr_debug("called initialize(%p)", callback);
struct mtd_k64f_data *context = &mtd_k64f_data;
memset(context, 0, sizeof(mtd_k64f_data));
context->currentCommand = ARM_STORAGE_OPERATION_INITIALIZE;
if (context->initialized) {
context->commandCompletionCallback = callback;
return 1; /* synchronous completion. */
}
if (controllerCurrentlyBusy()) {
/* The user cannot initiate any further FTFE commands until notified that the
* current command has completed.*/
return (int32_t)ARM_DRIVER_ERROR_BUSY;
}
clearErrorStatusBits();
context->commandCompletionCallback = callback;
/* Enable the command-completion interrupt. */
#if ASYNC_OPS
NVIC_SetVector(FTFE_IRQn, (uint32_t)ftfe_ccie_irq_handler);
NVIC_ClearPendingIRQ(FTFE_IRQn);
NVIC_EnableIRQ(FTFE_IRQn);
#endif
context->initialized = true;
return 1; /* synchronous completion. */
}
static int32_t uninitialize(void)
{
tr_debug("called uninitialize");
struct mtd_k64f_data *context = &mtd_k64f_data;
context->currentCommand = ARM_STORAGE_OPERATION_UNINITIALIZE;
if (!context->initialized) {
return ARM_DRIVER_ERROR;
}
/* Disable the command-completion interrupt. */
#if ASYNC_OPS
if (commandCompletionInterruptEnabled()) {
disbleCommandCompletionInterrupt();
NVIC_DisableIRQ(FTFE_IRQn);
NVIC_ClearPendingIRQ(FTFE_IRQn);
}
#endif
context->commandCompletionCallback = NULL;
context->initialized = false;
return 1; /* synchronous completion. */
}
static int32_t powerControl(ARM_POWER_STATE state)
{
tr_debug("called powerControl(%u)", state);
struct mtd_k64f_data *context = &mtd_k64f_data;
context->currentCommand = ARM_STORAGE_OPERATION_POWER_CONTROL;
context->powerState = state;
return 1; /* signal synchronous completion. */
}
static int32_t readData(uint64_t addr, void *data, uint32_t size)
{
tr_debug("called ReadData(%lu, %lu)", (uint32_t)addr, size);
struct mtd_k64f_data *context = &mtd_k64f_data;
context->currentCommand = ARM_STORAGE_OPERATION_READ_DATA;
if (!context->initialized) {
return ARM_DRIVER_ERROR; /* illegal */
}
/* Argument validation. */
if ((data == NULL) || (size == 0)) {
return ARM_DRIVER_ERROR_PARAMETER; /* illegal */
}
if ((getBlock(addr, NULL) != ARM_DRIVER_OK) || (getBlock(addr + size - 1, NULL) != ARM_DRIVER_OK)) {
return ARM_DRIVER_ERROR_PARAMETER; /* illegal address range */
}
context->currentCommand = ARM_STORAGE_OPERATION_READ_DATA;
memcpy(data, (const void *)(uintptr_t)addr, size);
return size; /* signal synchronous completion. */
}
static int32_t programData(uint64_t addr, const void *data, uint32_t size)
{
tr_debug("called ProgramData(%lu, %lu)", (uint32_t)addr, size);
struct mtd_k64f_data *context = &mtd_k64f_data;
if (!context->initialized) {
return (int32_t)ARM_DRIVER_ERROR; /* illegal */
}
/* argument validation */
if ((data == NULL) || (size == 0)) {
return ARM_DRIVER_ERROR_PARAMETER; /* illegal */
}
/* range check */
if ((getBlock(addr, NULL) != ARM_DRIVER_OK) || (getBlock(addr + size - 1, NULL) != ARM_DRIVER_OK)) {
return ARM_DRIVER_ERROR_PARAMETER; /* illegal address range */
}
/* alignment */
if (((addr % PROGRAM_UNIT) != 0) || ((size % PROGRAM_UNIT) != 0)) {
return ARM_DRIVER_ERROR_PARAMETER;
}
/* programmability */
if (checkForEachBlockInRange(addr, size, blockIsProgrammable) != ARM_DRIVER_OK) {
return ARM_STORAGE_ERROR_NOT_PROGRAMMABLE;
}
if (controllerCurrentlyBusy()) {
/* The user cannot initiate any further FTFE commands until notified that the
* current command has completed.*/
return ARM_DRIVER_ERROR_BUSY;
}
context->currentCommand = ARM_STORAGE_OPERATION_PROGRAM_DATA;
context->sizeofCurrentOperation = size;
context->amountLeftToOperate = size;
context->currentOperatingData = data;
context->currentOperatingStorageAddress = addr;
clearErrorStatusBits();
setupNextProgramData(context);
return executeCommand(context);
}
static int32_t erase(uint64_t addr, uint32_t size)
{
tr_debug("called erase(%lu, %lu)", (uint32_t)addr, size);
struct mtd_k64f_data *context = &mtd_k64f_data;
if (!context->initialized) {
return (int32_t)ARM_DRIVER_ERROR; /* illegal */
}
/* argument validation */
if (size == 0) {
return ARM_DRIVER_ERROR_PARAMETER;
}
/* range check */
if ((getBlock(addr, NULL) != ARM_DRIVER_OK) || (getBlock(addr + size - 1, NULL) != ARM_DRIVER_OK)) {
return ARM_DRIVER_ERROR_PARAMETER; /* illegal address range */
}
/* alignment */
if (((addr % ERASE_UNIT) != 0) || ((size % ERASE_UNIT) != 0)) {
return ARM_DRIVER_ERROR_PARAMETER;
}
/* erasability */
if (checkForEachBlockInRange(addr, size, blockIsErasable) != ARM_DRIVER_OK) {
return ARM_STORAGE_ERROR_NOT_ERASABLE;
}
if (controllerCurrentlyBusy()) {
/* The user cannot initiate any further FTFE commands until notified that the
* current command has completed.*/
return (int32_t)ARM_DRIVER_ERROR_BUSY;
}
context->currentCommand = ARM_STORAGE_OPERATION_ERASE;
context->currentOperatingStorageAddress = addr;
context->sizeofCurrentOperation = size;
context->amountLeftToOperate = size;
clearErrorStatusBits();
setupNextEraseCheck(context);
return executeCommand(context);
}
static int32_t eraseAll(void)
{
tr_debug("called eraseAll");
struct mtd_k64f_data *context = &mtd_k64f_data;
if (!context->initialized) {
return (int32_t)ARM_DRIVER_ERROR; /* illegal */
}
/* unless we are managing all of block 1, we shouldn't allow chip-erase. */
if ((caps.erase_all != 1) ||
((sizeof(blockTable) / sizeof(ARM_STORAGE_BLOCK)) != 1) || /* there are more than one flash blocks */
(blockTable[0].addr != BLOCK1_START_ADDR) ||
(blockTable[0].size != BLOCK1_SIZE)) {
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
if (controllerCurrentlyBusy()) {
/* The user cannot initiate any further FTFE commands until notified that the
* current command has completed.*/
return (int32_t)ARM_DRIVER_ERROR_BUSY;
}
context->currentCommand = ARM_STORAGE_OPERATION_ERASE_ALL;
clearErrorStatusBits();
/* Program FCCOB to load the required command parameters. */
setupEraseBlock(BLOCK1_START_ADDR);
return executeCommand(context);
}
static ARM_STORAGE_STATUS getStatus(void)
{
struct mtd_k64f_data *context = &mtd_k64f_data;
ARM_STORAGE_STATUS status = {
.busy = 0,
.error = 0,
};
if (!context->initialized) {
status.error = 1;
return status;
}
if (controllerCurrentlyBusy()) {
status.busy = 1;
} else if (failedWithAccessError() || failedWithProtectionError() || failedWithRunTimeError()) {
status.error = 1;
}
return status;
}
static int32_t getInfo(ARM_STORAGE_INFO *infoP)
{
memcpy(infoP, &info, sizeof(ARM_STORAGE_INFO));
return ARM_DRIVER_OK;
}
static uint32_t resolveAddress(uint64_t addr)
{
return (uint32_t)addr;
}
int32_t nextBlock(const ARM_STORAGE_BLOCK *prevP, ARM_STORAGE_BLOCK *nextP)
{
if (prevP == NULL) {
/* fetching the first block (instead of next) */
if (nextP) {
memcpy(nextP, &blockTable[0], sizeof(ARM_STORAGE_BLOCK));
}
return ARM_DRIVER_OK;
}
static const size_t NUM_SEGMENTS = sizeof(blockTable) / sizeof(ARM_STORAGE_BLOCK);
for (size_t index = 0; (NUM_SEGMENTS > 1) && (index < (NUM_SEGMENTS - 1)); index++) {
if ((blockTable[index].addr == prevP->addr) && (blockTable[index].size == prevP->size)) {
if (nextP) {
memcpy(nextP, &blockTable[index + 1], sizeof(ARM_STORAGE_BLOCK));
}
return ARM_DRIVER_OK;
}
}
if (nextP) {
nextP->addr = ARM_STORAGE_INVALID_OFFSET;
nextP->size = 0;
}
return ARM_DRIVER_ERROR;
}
int32_t getBlock(uint64_t addr, ARM_STORAGE_BLOCK *blockP)
{
static const size_t NUM_SEGMENTS = sizeof(blockTable) / sizeof(ARM_STORAGE_BLOCK);
const ARM_STORAGE_BLOCK *iter = &blockTable[0];
for (size_t index = 0; index < NUM_SEGMENTS; ++index, ++iter) {
if ((addr >= iter->addr) && (addr < (iter->addr + iter->size))) {
if (blockP) {
memcpy(blockP, iter, sizeof(ARM_STORAGE_BLOCK));
}
return ARM_DRIVER_OK;
}
}
if (blockP) {
blockP->addr = ARM_STORAGE_INVALID_OFFSET;
blockP->size = 0;
}
return ARM_DRIVER_ERROR;
}
ARM_DRIVER_STORAGE ARM_Driver_Storage_MTD_K64F = {
.GetVersion = getVersion,
.GetCapabilities = getCapabilities,
.Initialize = initialize,
.Uninitialize = uninitialize,
.PowerControl = powerControl,
.ReadData = readData,
.ProgramData = programData,
.Erase = erase,
.EraseAll = eraseAll,
.GetStatus = getStatus,
.GetInfo = getInfo,
.ResolveAddress = resolveAddress,
.GetNextBlock = nextBlock,
.GetBlock = getBlock
};