fsl_ftfx_controller.c File Reference

Flash controller command numbers
enum	_ftfx_ram_func_constants { kFTFx_RamFuncMaxSizeInWords = 16U }
	Constants for execute-in-RAM flash function. More...
typedef void(*	callFtfxRunCommand_t) (FTFx_REG8_ACCESS_TYPE ftfx_fstat)
	A function pointer used to point to relocated flash_run_command()

Enumeration for Flash security register code
enum	_ftfx_fsec_register_code { kFTFx_FsecRegCode_KEYEN_Enabled = 0x80U , kFTFx_FsecRegCode_SEC_Unsecured = 0x02U }
enum	_ftfx_pflash_config_area_range { kFTFx_PflashConfigAreaStart = 0x400U , kFTFx_PflashConfigAreaEnd = 0x40FU }
	Enumeration for flash config area. More...
static const uint16_t	s_ftfxRunCommandFunctionCode []
	Position independent code of flash_run_command()
static uint32_t	s_ftfxRunCommand [kFTFx_RamFuncMaxSizeInWords]
	A static buffer used to hold flash_run_command()
static volatile uint32_t *const	kFCCOBx = (volatile uint32_t *)&FTFx_FCCOB3_REG
	Access to FTFx Registers.
static const uint16_t	kEepromDensities [16]
	Table of eeprom sizes.
static const uint32_t	kDflashDensities [16]
	Table of dflash sizes.
static status_t	ftfx_init_ifr (ftfx_config_t *config)
	Init IFR memory related info.
static void	ftfx_copy_run_command_to_ram (uint32_t *ftfxRunCommand)
	Copy flash_run_command() to RAM.
static status_t	ftfx_command_sequence (ftfx_config_t *config)
	Internal function Flash command sequence. Called by driver APIs only.
static status_t	ftfx_check_mem_range (ftfx_config_t *config, uint32_t startAddress, uint32_t lengthInBytes, uint8_t alignmentBaseline)
	Validates the range and alignment of the given address range.
static status_t	ftfx_check_user_key (uint32_t key)
	Validates the given user key for flash erase APIs.
static uint32_t	ftfx_read_word_from_byte_address (const uint8_t *src)
	Reads word from byte address.
static void	ftfx_write_word_to_byte_address (uint8_t *dst, uint32_t word)
	Writes word to byte address.
static status_t	ftfx_check_resource_range (ftfx_config_t *config, uint32_t start, uint32_t lengthInBytes, uint32_t alignmentBaseline, ftfx_read_resource_opt_t option)
	Validates the range of the given resource address.
static status_t	ftfx_check_flexram_function_option (ftfx_flexram_func_opt_t option)
	Validates the gived flexram function option.
static status_t	ftfx_check_swap_control_option (ftfx_swap_control_opt_t option)
	Validates the gived swap control option.
status_t	FTFx_API_Init (ftfx_config_t *config)
	Initializes the global flash properties structure members.
status_t	FTFx_API_UpdateFlexnvmPartitionStatus (ftfx_config_t *config)
	Updates FlexNVM memory partition status according to data flash 0 IFR.
status_t	FTFx_CMD_Erase (ftfx_config_t *config, uint32_t start, uint32_t lengthInBytes, uint32_t key)
	Erases the flash sectors encompassed by parameters passed into function.
status_t	FTFx_CMD_EraseAll (ftfx_config_t *config, uint32_t key)
	Erases entire flash.
status_t	FTFx_CMD_EraseAllUnsecure (ftfx_config_t *config, uint32_t key)
	Erases the entire flash, including protected sectors.
status_t	FTFx_CMD_EraseAllExecuteOnlySegments (ftfx_config_t *config, uint32_t key)
	Erases all program flash execute-only segments defined by the FXACC registers.
status_t	FTFx_CMD_Program (ftfx_config_t *config, uint32_t start, uint8_t *src, uint32_t lengthInBytes)
	Programs flash with data at locations passed in through parameters.
status_t	FTFx_CMD_ProgramOnce (ftfx_config_t *config, uint32_t index, uint8_t *src, uint32_t lengthInBytes)
	Programs Program Once Field through parameters.
status_t	FTFx_CMD_ProgramSection (ftfx_config_t *config, uint32_t start, uint8_t *src, uint32_t lengthInBytes)
	Programs flash with data at locations passed in through parameters via the Program Section command.
status_t	FTFx_CMD_ProgramPartition (ftfx_config_t *config, ftfx_partition_flexram_load_opt_t option, uint32_t eepromDataSizeCode, uint32_t flexnvmPartitionCode)
	Prepares the FlexNVM block for use as data flash, EEPROM backup, or a combination of both and initializes the FlexRAM.
status_t	FTFx_CMD_ReadOnce (ftfx_config_t *config, uint32_t index, uint8_t *dst, uint32_t lengthInBytes)
	Reads the Program Once Field through parameters.
status_t	FTFx_CMD_ReadResource (ftfx_config_t *config, uint32_t start, uint8_t *dst, uint32_t lengthInBytes, ftfx_read_resource_opt_t option)
	Reads the resource with data at locations passed in through parameters.
status_t	FTFx_CMD_VerifyErase (ftfx_config_t *config, uint32_t start, uint32_t lengthInBytes, ftfx_margin_value_t margin)
	Verifies an erasure of the desired flash area at a specified margin level.
status_t	FTFx_CMD_VerifyEraseAll (ftfx_config_t *config, ftfx_margin_value_t margin)
	Verifies erasure of the entire flash at a specified margin level.
status_t	FTFx_CMD_VerifyEraseAllExecuteOnlySegments (ftfx_config_t *config, ftfx_margin_value_t margin)
	Verifies whether the program flash execute-only segments have been erased to the specified read margin level.
status_t	FTFx_CMD_VerifyProgram (ftfx_config_t *config, uint32_t start, uint32_t lengthInBytes, const uint8_t *expectedData, ftfx_margin_value_t margin, uint32_t *failedAddress, uint32_t *failedData)
	Verifies programming of the desired flash area at a specified margin level.
status_t	FTFx_CMD_SecurityBypass (ftfx_config_t *config, const uint8_t *backdoorKey)
	Allows users to bypass security with a backdoor key.
status_t	FTFx_REG_GetSecurityState (ftfx_config_t *config, ftfx_security_state_t *state)
	Returns the security state via the pointer passed into the function.
status_t	FTFx_CMD_SetFlexramFunction (ftfx_config_t *config, ftfx_flexram_func_opt_t option)
	Sets the FlexRAM function command.
status_t	FTFx_CMD_SwapControl (ftfx_config_t *config, uint32_t address, ftfx_swap_control_opt_t option, ftfx_swap_state_config_t *returnInfo)
	Configures the Swap function or checks the swap state of the Flash module.

Typedef Documentation

callFtfxRunCommand_t

typedef void(* callFtfxRunCommand_t) (FTFx_REG8_ACCESS_TYPE ftfx_fstat)

A function pointer used to point to relocated flash_run_command()

Definition at line 81 of file fsl_ftfx_controller.c.

Enumeration Type Documentation

_ftfx_fsec_register_code

enum _ftfx_fsec_register_code

Enumerator
kFTFx_FsecRegCode_KEYEN_Enabled
kFTFx_FsecRegCode_SEC_Unsecured

Definition at line 87 of file fsl_ftfx_controller.c.

{
    kFTFx_FsecRegCode_KEYEN_Enabled = 0x80U,
    kFTFx_FsecRegCode_SEC_Unsecured = 0x02U
};

_ftfx_pflash_config_area_range

enum _ftfx_pflash_config_area_range

Enumeration for flash config area.

Enumerator
kFTFx_PflashConfigAreaStart
kFTFx_PflashConfigAreaEnd

Definition at line 97 of file fsl_ftfx_controller.c.

{
    kFTFx_PflashConfigAreaStart = 0x400U,
    kFTFx_PflashConfigAreaEnd = 0x40FU
};

_ftfx_ram_func_constants

enum _ftfx_ram_func_constants

Constants for execute-in-RAM flash function.

Enumerator
kFTFx_RamFuncMaxSizeInWords	The maximum size of execute-in-RAM function.

Definition at line 75 of file fsl_ftfx_controller.c.

{
    kFTFx_RamFuncMaxSizeInWords = 16U, /*!< The maximum size of execute-in-RAM function.*/
};

Function Documentation

FTFx_API_Init()

status_t FTFx_API_Init

(

ftfx_config_t *

config

)

Initializes the global flash properties structure members.

This function checks and initializes the Flash module for the other Flash APIs.

Parameters

config

Pointer to the storage for the driver runtime state.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.

Definition at line 240 of file fsl_ftfx_controller.c.

{
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    config->flexramBlockBase = FSL_FEATURE_FLASH_FLEX_RAM_START_ADDRESS;
    config->flexramTotalSize = FSL_FEATURE_FLASH_FLEX_RAM_SIZE;
 
    /* copy required flash command to RAM */
#if FTFx_DRIVER_IS_FLASH_RESIDENT
    if (NULL == config->runCmdFuncAddr)
    {
#if FTFx_DRIVER_IS_EXPORTED
        return kStatus_FTFx_ExecuteInRamFunctionNotReady;
#else
        config->runCmdFuncAddr = s_ftfxRunCommand;
#endif /* FTFx_DRIVER_IS_EXPORTED */
    }
    ftfx_copy_run_command_to_ram(config->runCmdFuncAddr);
#endif /* FTFx_DRIVER_IS_FLASH_RESIDENT */
 
    ftfx_init_ifr(config);
 
    return kStatus_FTFx_Success;
}

Referenced by FLEXNVM_Init().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_API_UpdateFlexnvmPartitionStatus()

status_t FTFx_API_UpdateFlexnvmPartitionStatus

(

ftfx_config_t *

config

)

Updates FlexNVM memory partition status according to data flash 0 IFR.

This function updates FlexNVM memory partition status.

Parameters

config

Pointer to the storage for the driver runtime state.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_PartitionStatusUpdateFailure	Failed to update the partition status.

Definition at line 269 of file fsl_ftfx_controller.c.

{
    struct _dflash_ifr_field_config
    {
        uint32_t reserved0;
        uint8_t FlexNVMPartitionCode;
        uint8_t EEPROMDataSetSize;
        uint16_t reserved1;
    } dataIFRReadOut;
    uint32_t flexnvmInfoIfrAddr;
    status_t returnCode;
 
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    flexnvmInfoIfrAddr = config->ifrDesc.resRange.dflashIfrStart + config->ifrDesc.resRange.ifrMemSize - sizeof(dataIFRReadOut);
 
#if defined(FSL_FEATURE_FLASH_HAS_READ_RESOURCE_CMD) && FSL_FEATURE_FLASH_HAS_READ_RESOURCE_CMD
    /* Get FlexNVM memory partition info from data flash IFR */
    returnCode = FTFx_CMD_ReadResource(config, flexnvmInfoIfrAddr, (uint8_t *)&dataIFRReadOut,
                                       sizeof(dataIFRReadOut), kFTFx_ResourceOptionFlashIfr);
    if (returnCode != kStatus_FTFx_Success)
    {
        return kStatus_FTFx_PartitionStatusUpdateFailure;
    }
#else
#error "Cannot get FlexNVM memory partition info"
#endif
 
    /* Fill out partitioned EEPROM size */
    dataIFRReadOut.EEPROMDataSetSize &= 0x0FU;
    config->eepromTotalSize = kEepromDensities[dataIFRReadOut.EEPROMDataSetSize];
 
    /* Fill out partitioned DFlash size */
    dataIFRReadOut.FlexNVMPartitionCode &= 0x0FU;
    config->flashDesc.totalSize = kDflashDensities[dataIFRReadOut.FlexNVMPartitionCode];
 
    return kStatus_FTFx_Success;
}

Referenced by FLEXNVM_Init(), FTFx_CMD_EraseAll(), and FTFx_CMD_EraseAllUnsecure().

Here is the call graph for this function:

Here is the caller graph for this function:

ftfx_check_flexram_function_option()

static status_t ftfx_check_flexram_function_option ( ftfx_flexram_func_opt_t  option )

inlinestatic

Validates the gived flexram function option.

Definition at line 1380 of file fsl_ftfx_controller.c.

{
    if ((option != kFTFx_FlexramFuncOptAvailableAsRam) &&
        (option != kFTFx_FlexramFuncOptAvailableForEeprom))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    return kStatus_FTFx_Success;
}

Referenced by FTFx_CMD_SetFlexramFunction().

Here is the caller graph for this function:

ftfx_check_mem_range()

static status_t ftfx_check_mem_range ( ftfx_config_t *  config, uint32_t  startAddress, uint32_t  lengthInBytes, uint8_t  alignmentBaseline  )

static

Validates the range and alignment of the given address range.

Definition at line 1243 of file fsl_ftfx_controller.c.

{
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* Verify the start and length are alignmentBaseline aligned. */
    if ((startAddress & (alignmentBaseline - 1)) || (lengthInBytes & (alignmentBaseline - 1)))
    {
        return kStatus_FTFx_AlignmentError;
    }
 
    /* check for valid range of the target addresses */
    if ((startAddress >= config->flashDesc.blockBase) &&
        ((startAddress + lengthInBytes) <= (config->flashDesc.blockBase + config->flashDesc.totalSize)))
    {
        return kStatus_FTFx_Success;
    }
 
    return kStatus_FTFx_AddressError;
}

Referenced by FTFx_CMD_Erase(), FTFx_CMD_Program(), FTFx_CMD_ProgramSection(), FTFx_CMD_VerifyErase(), and FTFx_CMD_VerifyProgram().

Here is the caller graph for this function:

ftfx_check_resource_range()

static status_t ftfx_check_resource_range ( ftfx_config_t *  config, uint32_t  start, uint32_t  lengthInBytes, uint32_t  alignmentBaseline, ftfx_read_resource_opt_t  option  )

static

Validates the range of the given resource address.

Definition at line 1321 of file fsl_ftfx_controller.c.

{
    status_t status;
    uint32_t maxReadbleAddress;
 
    if ((start & (alignmentBaseline - 1)) || (lengthInBytes & (alignmentBaseline - 1)))
    {
        return kStatus_FTFx_AlignmentError;
    }
 
    status = kStatus_FTFx_Success;
 
    maxReadbleAddress = start + lengthInBytes - 1;
    if (option == kFTFx_ResourceOptionVersionId)
    {
        if ((start != config->ifrDesc.resRange.versionIdStart) ||
            (lengthInBytes != config->ifrDesc.resRange.versionIdSize))
        {
            status = kStatus_FTFx_InvalidArgument;
        }
    }
    else if (option == kFTFx_ResourceOptionFlashIfr)
    {
        if ((start >= config->ifrDesc.resRange.pflashIfrStart) &&
            (maxReadbleAddress < (config->ifrDesc.resRange.pflashIfrStart + config->ifrDesc.resRange.ifrMemSize)))
        {
        }
#if FSL_FEATURE_FLASH_HAS_FLEX_NVM
        else if ((start >= config->ifrDesc.resRange.dflashIfrStart) &&
                 (maxReadbleAddress < (config->ifrDesc.resRange.dflashIfrStart + config->ifrDesc.resRange.ifrMemSize)))
        {
        }
#endif
#if FSL_FEATURE_FLASH_HAS_SWAP_CONTROL_CMD
        else if ((start >= config->ifrDesc.resRange.pflashSwapIfrStart) &&
                 (maxReadbleAddress < (config->ifrDesc.resRange.pflashSwapIfrStart + config->ifrDesc.resRange.ifrMemSize)))
        {
        }
#endif
        else
        {
            status = kStatus_FTFx_InvalidArgument;
        }
    }
    else
    {
        status = kStatus_FTFx_InvalidArgument;
    }
 
    return status;
}

Referenced by FTFx_CMD_ReadResource().

Here is the caller graph for this function:

ftfx_check_swap_control_option()

static status_t ftfx_check_swap_control_option ( ftfx_swap_control_opt_t  option )

static

Validates the gived swap control option.

Definition at line 1394 of file fsl_ftfx_controller.c.

{
    if ((option == kFTFx_SwapControlOptionIntializeSystem) || (option == kFTFx_SwapControlOptionSetInUpdateState) ||
        (option == kFTFx_SwapControlOptionSetInCompleteState) || (option == kFTFx_SwapControlOptionReportStatus) ||
        (option == kFTFx_SwapControlOptionDisableSystem))
    {
        return kStatus_FTFx_Success;
    }
 
    return kStatus_FTFx_InvalidArgument;
}

Referenced by FTFx_CMD_SwapControl().

Here is the caller graph for this function:

ftfx_check_user_key()

static status_t ftfx_check_user_key ( uint32_t  key )

static

Validates the given user key for flash erase APIs.

Definition at line 1270 of file fsl_ftfx_controller.c.

{
    /* Validate the user key */
    if (key != kFTFx_ApiEraseKey)
    {
        return kStatus_FTFx_EraseKeyError;
    }
 
    return kStatus_FTFx_Success;
}

Referenced by FTFx_CMD_Erase(), FTFx_CMD_EraseAll(), FTFx_CMD_EraseAllExecuteOnlySegments(), and FTFx_CMD_EraseAllUnsecure().

Here is the caller graph for this function:

FTFx_CMD_Erase()

status_t FTFx_CMD_Erase	(	ftfx_config_t *	config,
		uint32_t	start,
		uint32_t	lengthInBytes,
		uint32_t	key
	)

Erases the flash sectors encompassed by parameters passed into function.

This function erases the appropriate number of flash sectors based on the desired start address and length.

Parameters

config	The pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be erased. The start address does not need to be sector-aligned but must be word-aligned.
lengthInBytes	The length, given in bytes (not words or long-words) to be erased. Must be word-aligned.
key	The value used to validate all flash erase APIs.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	The parameter is not aligned with the specified baseline.
kStatus_FTFx_AddressError	The address is out of range.
kStatus_FTFx_EraseKeyError	The API erase key is invalid.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 312 of file fsl_ftfx_controller.c.

{
    uint32_t sectorSize;
    uint32_t endAddress;      /* storing end address */
    uint32_t numberOfSectors; /* number of sectors calculated by endAddress */
    status_t returnCode;
 
    /* Check the supplied address range. */
    returnCode = ftfx_check_mem_range(config, start, lengthInBytes, config->opsConfig.addrAligment.sectorCmd);
    if (returnCode)
    {
        return returnCode;
    }
 
    /* Validate the user key */
    returnCode = ftfx_check_user_key(key);
    if (returnCode)
    {
        return returnCode;
    }
 
    start = config->opsConfig.convertedAddress;
    sectorSize = config->flashDesc.sectorSize;
 
    /* calculating Flash end address */
    endAddress = start + lengthInBytes - 1;
 
    /* re-calculate the endAddress and align it to the start of the next sector
     * which will be used in the comparison below */
    if (endAddress % sectorSize)
    {
        numberOfSectors = endAddress / sectorSize + 1;
        endAddress = numberOfSectors * sectorSize - 1;
    }
 
    /* the start address will increment to the next sector address
     * until it reaches the endAdddress */
    while (start <= endAddress)
    {
        /* preparing passing parameter to erase a flash block */
        kFCCOBx[0] = BYTE2WORD_1_3(FTFx_ERASE_SECTOR, start);
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
 
        /* checking the success of command execution */
        if (kStatus_FTFx_Success != returnCode)
        {
            break;
        }
        else
        {
            /* Increment to the next sector */
            start += sectorSize;
        }
    }
 
    return (returnCode);
}

Referenced by FLEXNVM_DflashErase().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_EraseAll()

status_t FTFx_CMD_EraseAll	(	ftfx_config_t *	config,
		uint32_t	key
	)

Erases entire flash.

Parameters

config	Pointer to the storage for the driver runtime state.
key	A value used to validate all flash erase APIs.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_EraseKeyError	API erase key is invalid.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during command execution.
kStatus_FTFx_PartitionStatusUpdateFailure	Failed to update the partition status.

Definition at line 375 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* preparing passing parameter to erase all flash blocks */
    kFCCOBx[0] = BYTE2WORD_1_3(FTFx_ERASE_ALL_BLOCK, 0xFFFFFFU);
 
    /* Validate the user key */
    returnCode = ftfx_check_user_key(key);
    if (returnCode)
    {
        return returnCode;
    }
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
#if FSL_FEATURE_FLASH_HAS_FLEX_NVM
    /* Data flash IFR will be erased by erase all command, so we need to
     *  update FlexNVM memory partition status synchronously */
    if (returnCode == kStatus_FTFx_Success)
    {
        returnCode = FTFx_API_UpdateFlexnvmPartitionStatus(config);
    }
#endif
 
    return returnCode;
}

Referenced by FLEXNVM_EraseAll().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_EraseAllExecuteOnlySegments()

status_t FTFx_CMD_EraseAllExecuteOnlySegments	(	ftfx_config_t *	config,
		uint32_t	key
	)

Erases all program flash execute-only segments defined by the FXACC registers.

Parameters

config	Pointer to the storage for the driver runtime state.
key	A value used to validate all flash erase APIs.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_EraseKeyError	API erase key is invalid.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 445 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* preparing passing parameter to erase all execute-only segments
     * 1st element for the FCCOB register */
    kFCCOBx[0] = BYTE2WORD_1_3(FTFx_ERASE_ALL_EXECUTE_ONLY_SEGMENT, 0xFFFFFFU);
 
    /* Validate the user key */
    returnCode = ftfx_check_user_key(key);
    if (returnCode)
    {
        return returnCode;
    }
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
    return returnCode;
}

Here is the call graph for this function:

FTFx_CMD_EraseAllUnsecure()

status_t FTFx_CMD_EraseAllUnsecure	(	ftfx_config_t *	config,
		uint32_t	key
	)

Erases the entire flash, including protected sectors.

Parameters

config	Pointer to the storage for the driver runtime state.
key	A value used to validate all flash erase APIs.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_EraseKeyError	API erase key is invalid.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during command execution.
kStatus_FTFx_PartitionStatusUpdateFailure	Failed to update the partition status.

Definition at line 410 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* Prepare passing parameter to erase all flash blocks (unsecure). */
    kFCCOBx[0] = BYTE2WORD_1_3(FTFx_ERASE_ALL_BLOCK_UNSECURE, 0xFFFFFFU);
 
    /* Validate the user key */
    returnCode = ftfx_check_user_key(key);
    if (returnCode)
    {
        return returnCode;
    }
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
#if FSL_FEATURE_FLASH_HAS_FLEX_NVM
    /* Data flash IFR will be erased by erase all unsecure command, so we need to
     *  update FlexNVM memory partition status synchronously */
    if (returnCode == kStatus_FTFx_Success)
    {
        returnCode = FTFx_API_UpdateFlexnvmPartitionStatus(config);
    }
#endif
 
    return returnCode;
}

Referenced by FLEXNVM_EraseAllUnsecure().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_Program()

status_t FTFx_CMD_Program	(	ftfx_config_t *	config,
		uint32_t	start,
		uint8_t *	src,
		uint32_t	lengthInBytes
	)

Programs flash with data at locations passed in through parameters.

This function programs the flash memory with the desired data for a given flash area as determined by the start address and the length.

Parameters

config	A pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be programmed. Must be word-aligned.
src	A pointer to the source buffer of data that is to be programmed into the flash.
lengthInBytes	The length, given in bytes (not words or long-words), to be programmed. Must be word-aligned.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with the specified baseline.
kStatus_FTFx_AddressError	Address is out of range.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 471 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
    uint8_t blockWriteUnitSize = config->opsConfig.addrAligment.blockWriteUnitSize;
 
    if (src == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* Check the supplied address range. */
    returnCode = ftfx_check_mem_range(config, start, lengthInBytes, blockWriteUnitSize);
    if (returnCode)
    {
        return returnCode;
    }
 
    start = config->opsConfig.convertedAddress;
 
    while (lengthInBytes > 0)
    {
        /* preparing passing parameter to program the flash block */
        kFCCOBx[1] = ftfx_read_word_from_byte_address((const uint8_t*)src);
        src += 4;
 
        if (4 == blockWriteUnitSize)
        {
            kFCCOBx[0] = BYTE2WORD_1_3(FTFx_PROGRAM_LONGWORD, start);
        }
        else if (8 == blockWriteUnitSize)
        {
            kFCCOBx[2] = ftfx_read_word_from_byte_address((const uint8_t*)src);
            src += 4;
            kFCCOBx[0] = BYTE2WORD_1_3(FTFx_PROGRAM_PHRASE, start);
        }
        else
        {
        }
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
 
        /* checking for the success of command execution */
        if (kStatus_FTFx_Success != returnCode)
        {
            break;
        }
        else
        {
            /* update start address for next iteration */
            start += blockWriteUnitSize;
 
            /* update lengthInBytes for next iteration */
            lengthInBytes -= blockWriteUnitSize;
        }
    }
 
    return (returnCode);
}

Referenced by FLEXNVM_DflashProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_ProgramOnce()

status_t FTFx_CMD_ProgramOnce	(	ftfx_config_t *	config,
		uint32_t	index,
		uint8_t *	src,
		uint32_t	lengthInBytes
	)

Programs Program Once Field through parameters.

This function programs the Program Once Field with the desired data for a given flash area as determined by the index and length.

Parameters

config	A pointer to the storage for the driver runtime state.
index	The index indicating which area of the Program Once Field to be programmed.
src	A pointer to the source buffer of data that is to be programmed into the Program Once Field.
lengthInBytes	The length, given in bytes (not words or long-words), to be programmed. Must be word-aligned.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 534 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if ((config == NULL) || (src == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* pass paramters to FTFx */
    kFCCOBx[0] = BYTE2WORD_1_1_2(FTFx_PROGRAM_ONCE, index, 0xFFFFU);
 
    kFCCOBx[1] = ftfx_read_word_from_byte_address((const uint8_t*)src);
 
    /* Note: Have to seperate the first index from the rest if it equals 0
     * to avoid a pointless comparison of unsigned int to 0 compiler warning */
    if (config->ifrDesc.feature.has8ByteIdxSupport)
    {
        if (config->ifrDesc.feature.has4ByteIdxSupport)
        {
            if (((index == config->ifrDesc.idxInfo.mix8byteIdxStart) ||
                 ((index >= config->ifrDesc.idxInfo.mix8byteIdxStart + 1) && (index <= config->ifrDesc.idxInfo.mix8byteIdxStart))) &&
                  (lengthInBytes == 8))
            {
                kFCCOBx[2] = ftfx_read_word_from_byte_address((const uint8_t*)src + 4);
            }
        }
        else
        {
            kFCCOBx[2] = ftfx_read_word_from_byte_address((const uint8_t*)src + 4);
        }
    }
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
    return returnCode;
}

Here is the call graph for this function:

FTFx_CMD_ProgramPartition()

status_t FTFx_CMD_ProgramPartition	(	ftfx_config_t *	config,
		ftfx_partition_flexram_load_opt_t	option,
		uint32_t	eepromDataSizeCode,
		uint32_t	flexnvmPartitionCode
	)

Prepares the FlexNVM block for use as data flash, EEPROM backup, or a combination of both and initializes the FlexRAM.

Parameters

config	Pointer to storage for the driver runtime state.
option	The option used to set FlexRAM load behavior during reset.
eepromDataSizeCode	Determines the amount of FlexRAM used in each of the available EEPROM subsystems.
flexnvmPartitionCode	Specifies how to split the FlexNVM block between data flash memory and EEPROM backup memory supporting EEPROM functions.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	Invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during command execution.

Definition at line 695 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* eepromDataSizeCode[7:6], flexnvmPartitionCode[7:4] should be all 1'b0
     *  or it will cause access error. */
    /* eepromDataSizeCode &= 0x3FU;  */
    /* flexnvmPartitionCode &= 0x0FU; */
 
    /* preparing passing parameter to program the flash block */
    kFCCOBx[0] = BYTE2WORD_1_2_1(FTFx_PROGRAM_PARTITION, 0xFFFFU, option);
    kFCCOBx[1] = BYTE2WORD_1_1_2(eepromDataSizeCode, flexnvmPartitionCode, 0xFFFFU);
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
#if FSL_FEATURE_FLASH_HAS_FLEX_NVM
    /* Data flash IFR will be updated by program partition command during reset sequence,
     * so we just set reserved values for partitioned FlexNVM size here */
    config->eepromTotalSize = 0xFFFFU;
    config->flashDesc.totalSize = 0xFFFFFFFFU;
#endif
 
    return (returnCode);
}

Referenced by FLEXNVM_ProgramPartition().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_ProgramSection()

status_t FTFx_CMD_ProgramSection	(	ftfx_config_t *	config,
		uint32_t	start,
		uint8_t *	src,
		uint32_t	lengthInBytes
	)

Programs flash with data at locations passed in through parameters via the Program Section command.

This function programs the flash memory with the desired data for a given flash area as determined by the start address and length.

Parameters

config	A pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be programmed. Must be word-aligned.
src	A pointer to the source buffer of data that is to be programmed into the flash.
lengthInBytes	The length, given in bytes (not words or long-words), to be programmed. Must be word-aligned.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with specified baseline.
kStatus_FTFx_AddressError	Address is out of range.
kStatus_FTFx_SetFlexramAsRamError	Failed to set flexram as RAM.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during command execution.
kStatus_FTFx_RecoverFlexramAsEepromError	Failed to recover FlexRAM as EEPROM.

Definition at line 574 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
    uint32_t sectorSize;
    uint8_t aligmentInBytes = config->opsConfig.addrAligment.sectionCmd;
#if defined(FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD) && FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD
    bool needSwitchFlexRamMode = false;
#endif /* FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD */
 
    if (src == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* Check the supplied address range. */
    returnCode = ftfx_check_mem_range(config, start, lengthInBytes, aligmentInBytes);
    if (returnCode)
    {
        return returnCode;
    }
 
    start = config->opsConfig.convertedAddress;
    sectorSize = config->flashDesc.sectorSize;
 
#if defined(FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD) && FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD
    /* Switch function of FlexRAM if needed */
    if (!(FTFx->FCNFG & FTFx_FCNFG_RAMRDY_MASK))
    {
        needSwitchFlexRamMode = true;
 
        returnCode = FTFx_CMD_SetFlexramFunction(config, kFTFx_FlexramFuncOptAvailableAsRam);
        if (returnCode != kStatus_FTFx_Success)
        {
            return kStatus_FTFx_SetFlexramAsRamError;
        }
    }
#endif /* FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD */
 
    while (lengthInBytes > 0)
    {
        /* Make sure the write operation doesn't span two sectors */
        uint32_t endAddressOfCurrentSector = ALIGN_UP(start, sectorSize);
        uint32_t lengthTobeProgrammedOfCurrentSector;
        uint32_t currentOffset = 0;
 
        if (endAddressOfCurrentSector == start)
        {
            endAddressOfCurrentSector += sectorSize;
        }
 
        if (lengthInBytes + start > endAddressOfCurrentSector)
        {
            lengthTobeProgrammedOfCurrentSector = endAddressOfCurrentSector - start;
        }
        else
        {
            lengthTobeProgrammedOfCurrentSector = lengthInBytes;
        }
 
        /* Program Current Sector */
        while (lengthTobeProgrammedOfCurrentSector > 0)
        {
            /* Make sure the program size doesn't exceeds Acceleration RAM size */
            uint32_t programSizeOfCurrentPass;
            uint32_t numberOfPhases;
 
            if (lengthTobeProgrammedOfCurrentSector > config->flexramTotalSize)
            {
                programSizeOfCurrentPass = config->flexramTotalSize;
            }
            else
            {
                programSizeOfCurrentPass = lengthTobeProgrammedOfCurrentSector;
            }
 
            /* Copy data to FlexRAM */
            memcpy((void *)config->flexramBlockBase, src + currentOffset, programSizeOfCurrentPass);
            /* Set start address of the data to be programmed */
            kFCCOBx[0] = BYTE2WORD_1_3(FTFx_PROGRAM_SECTION, start + currentOffset);
            /* Set program size in terms of FEATURE_FLASH_SECTION_CMD_ADDRESS_ALIGMENT */
            numberOfPhases = programSizeOfCurrentPass / aligmentInBytes;
 
            kFCCOBx[1] = BYTE2WORD_2_2(numberOfPhases, 0xFFFFU);
 
            /* Peform command sequence */
            returnCode = ftfx_command_sequence(config);
 
            if (returnCode != kStatus_FTFx_Success)
            {
                return returnCode;
            }
 
            lengthTobeProgrammedOfCurrentSector -= programSizeOfCurrentPass;
            currentOffset += programSizeOfCurrentPass;
        }
 
        src += currentOffset;
        start += currentOffset;
        lengthInBytes -= currentOffset;
    }
 
#if defined(FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD) && FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD
    /* Restore function of FlexRAM if needed. */
    if (needSwitchFlexRamMode)
    {
        returnCode = FTFx_CMD_SetFlexramFunction(config, kFTFx_FlexramFuncOptAvailableForEeprom);
        if (returnCode != kStatus_FTFx_Success)
        {
            return kStatus_FTFx_RecoverFlexramAsEepromError;
        }
    }
#endif /* FSL_FEATURE_FLASH_HAS_SET_FLEXRAM_FUNCTION_CMD */
 
    return returnCode;
}

Referenced by FLEXNVM_DflashProgramSection().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_ReadOnce()

status_t FTFx_CMD_ReadOnce	(	ftfx_config_t *	config,
		uint32_t	index,
		uint8_t *	dst,
		uint32_t	lengthInBytes
	)

Reads the Program Once Field through parameters.

This function reads the read once feild with given index and length.

Parameters

config	A pointer to the storage for the driver runtime state.
index	The index indicating the area of program once field to be read.
dst	A pointer to the destination buffer of data that is used to store data to be read.
lengthInBytes	The length, given in bytes (not words or long-words), to be programmed. Must be word-aligned.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 730 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if ((config == NULL) || (dst == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* pass paramters to FTFx */
    kFCCOBx[0] = BYTE2WORD_1_1_2(FTFx_READ_ONCE, index, 0xFFFFU);
 
    /* calling flash command sequence function to execute the command */
    returnCode = ftfx_command_sequence(config);
 
    if (kStatus_FTFx_Success == returnCode)
    {
        ftfx_write_word_to_byte_address(dst, kFCCOBx[1]);
        /* Note: Have to seperate the first index from the rest if it equals 0
         *       to avoid a pointless comparison of unsigned int to 0 compiler warning */
        if (config->ifrDesc.feature.has8ByteIdxSupport)
        {
            if (config->ifrDesc.feature.has4ByteIdxSupport)
            {
                if (((index == config->ifrDesc.idxInfo.mix8byteIdxStart) ||
                     ((index >= config->ifrDesc.idxInfo.mix8byteIdxStart + 1) && (index <= config->ifrDesc.idxInfo.mix8byteIdxStart))) &&
                      (lengthInBytes == 8))
                {
                    ftfx_write_word_to_byte_address(dst + 4, kFCCOBx[2]);
                }
            }
            else
            {
                ftfx_write_word_to_byte_address(dst + 4, kFCCOBx[2]);
            }
        }
    }
 
    return returnCode;
}

Here is the call graph for this function:

FTFx_CMD_ReadResource()

status_t FTFx_CMD_ReadResource	(	ftfx_config_t *	config,
		uint32_t	start,
		uint8_t *	dst,
		uint32_t	lengthInBytes,
		ftfx_read_resource_opt_t	option
	)

Reads the resource with data at locations passed in through parameters.

This function reads the flash memory with the desired location for a given flash area as determined by the start address and length.

Parameters

config	A pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be programmed. Must be word-aligned.
dst	A pointer to the destination buffer of data that is used to store data to be read.
lengthInBytes	The length, given in bytes (not words or long-words), to be read. Must be word-aligned.
option	The resource option which indicates which area should be read back.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with the specified baseline.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 772 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if ((config == NULL) || (dst == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    uint8_t aligmentInBytes = config->opsConfig.addrAligment.resourceCmd;
 
    /* Check the supplied address range. */
    returnCode = ftfx_check_resource_range(config, start, lengthInBytes, aligmentInBytes, option);
    if (returnCode != kStatus_FTFx_Success)
    {
        return returnCode;
    }
 
    while (lengthInBytes > 0)
    {
        /* preparing passing parameter */
        kFCCOBx[0] = BYTE2WORD_1_3(FTFx_READ_RESOURCE, start);
        if (aligmentInBytes == 4)
        {
            kFCCOBx[2] = BYTE2WORD_1_3(option, 0xFFFFFFU);
        }
        else if (aligmentInBytes == 8)
        {
            kFCCOBx[1] = BYTE2WORD_1_3(option, 0xFFFFFFU);
        }
        else
        {
        }
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
 
        if (kStatus_FTFx_Success != returnCode)
        {
            break;
        }
 
        /* fetch data */
        ftfx_write_word_to_byte_address(dst, kFCCOBx[1]);
        dst += 4;
        if (aligmentInBytes == 8)
        {
            ftfx_write_word_to_byte_address(dst, kFCCOBx[2]);
            dst += 4;
        }
        /* update start address for next iteration */
        start += aligmentInBytes;
        /* update lengthInBytes for next iteration */
        lengthInBytes -= aligmentInBytes;
    }
 
    return (returnCode);
}

Referenced by FLEXNVM_ReadResource(), and FTFx_API_UpdateFlexnvmPartitionStatus().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_SecurityBypass()

status_t FTFx_CMD_SecurityBypass	(	ftfx_config_t *	config,
		const uint8_t *	backdoorKey
	)

Allows users to bypass security with a backdoor key.

If the MCU is in secured state, this function unsecures the MCU by comparing the provided backdoor key with ones in the flash configuration field.

Parameters

config	A pointer to the storage for the driver runtime state.
backdoorKey	A pointer to the user buffer containing the backdoor key.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 978 of file fsl_ftfx_controller.c.

{
    uint8_t registerValue; /* registerValue */
    status_t returnCode;   /* return code variable */
 
    if ((config == NULL) || (backdoorKey == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* set the default return code as kStatus_Success */
    returnCode = kStatus_FTFx_Success;
 
    /* Get flash security register value */
    registerValue = FTFx->FSEC;
 
    /* Check to see if flash is in secure state (any state other than 0x2)
     * If not, then skip this since flash is not secure */
    if (0x02 != (registerValue & 0x03))
    {
        /* preparing passing parameter to erase a flash block */
        kFCCOBx[0] = BYTE2WORD_1_3(FTFx_SECURITY_BY_PASS, 0xFFFFFFU);
        kFCCOBx[1] = BYTE2WORD_1_1_1_1(backdoorKey[0], backdoorKey[1], backdoorKey[2], backdoorKey[3]);
        kFCCOBx[2] = BYTE2WORD_1_1_1_1(backdoorKey[4], backdoorKey[5], backdoorKey[6], backdoorKey[7]);
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
    }
 
    return (returnCode);
}

Referenced by FLEXNVM_SecurityBypass().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_SetFlexramFunction()

status_t FTFx_CMD_SetFlexramFunction	(	ftfx_config_t *	config,
		ftfx_flexram_func_opt_t	option
	)

Sets the FlexRAM function command.

Parameters

config	A pointer to the storage for the driver runtime state.
option	The option used to set the work mode of FlexRAM.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 1049 of file fsl_ftfx_controller.c.

 {
     status_t status;
 
     if (config == NULL)
     {
         return kStatus_FTFx_InvalidArgument;
     }
 
     status = ftfx_check_flexram_function_option(option);
     if (status != kStatus_FTFx_Success)
     {
         return status;
     }
 
     /* preparing passing parameter to verify all block command */
     kFCCOBx[0] = BYTE2WORD_1_1_2(FTFx_SET_FLEXRAM_FUNCTION, option, 0xFFFFU);
 
     /* calling flash command sequence function to execute the command */
     return ftfx_command_sequence(config);
 }

Referenced by FLEXNVM_EepromWrite(), FLEXNVM_SetFlexramFunction(), and FTFx_CMD_ProgramSection().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_SwapControl()

status_t FTFx_CMD_SwapControl	(	ftfx_config_t *	config,
		uint32_t	address,
		ftfx_swap_control_opt_t	option,
		ftfx_swap_state_config_t *	returnInfo
	)

Configures the Swap function or checks the swap state of the Flash module.

Parameters

config	A pointer to the storage for the driver runtime state.
address	Address used to configure the flash Swap function.
option	The possible option used to configure Flash Swap function or check the flash Swap status
returnInfo	A pointer to the data which is used to return the information of flash Swap.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with specified baseline.
kStatus_FTFx_SwapIndicatorAddressError	Swap indicator address is invalid.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 1073 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
 
    if ((config == NULL) || (returnInfo == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    if (address & (FSL_FEATURE_FLASH_PFLASH_SWAP_CONTROL_CMD_ADDRESS_ALIGMENT - 1))
    {
        return kStatus_FTFx_AlignmentError;
    }
 
    /* Make sure address provided is in the lower half of Program flash but not in the Flash Configuration Field */
    if ((address >= (config->flashDesc.totalSize / 2)) ||
        ((address >= kFTFx_PflashConfigAreaStart) && (address <= kFTFx_PflashConfigAreaEnd)))
    {
        return kStatus_FTFx_SwapIndicatorAddressError;
    }
 
    /* Check the option. */
    returnCode = ftfx_check_swap_control_option(option);
    if (returnCode)
    {
        return returnCode;
    }
 
    kFCCOBx[0] = BYTE2WORD_1_3(FTFx_SWAP_CONTROL, address);
    kFCCOBx[1] = BYTE2WORD_1_3(option, 0xFFFFFFU);
 
    returnCode = ftfx_command_sequence(config);
 
    returnInfo->flashSwapState = (ftfx_swap_state_t)FTFx_FCCOB5_REG;
    returnInfo->currentSwapBlockStatus = (ftfx_swap_block_status_t)FTFx_FCCOB6_REG;
    returnInfo->nextSwapBlockStatus = (ftfx_swap_block_status_t)FTFx_FCCOB7_REG;
 
    return returnCode;
}

Here is the call graph for this function:

FTFx_CMD_VerifyErase()

status_t FTFx_CMD_VerifyErase	(	ftfx_config_t *	config,
		uint32_t	start,
		uint32_t	lengthInBytes,
		ftfx_margin_value_t	margin
	)

Verifies an erasure of the desired flash area at a specified margin level.

This function checks the appropriate number of flash sectors based on the desired start address and length to check whether the flash is erased to the specified read margin level.

Parameters

config	A pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be verified. The start address does not need to be sector-aligned but must be word-aligned.
lengthInBytes	The length, given in bytes (not words or long-words), to be verified. Must be word-aligned.
margin	Read margin choice.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with specified baseline.
kStatus_FTFx_AddressError	Address is out of range.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 836 of file fsl_ftfx_controller.c.

{
    /* Check arguments. */
    uint32_t blockSize;
    uint32_t nextBlockStartAddress;
    uint32_t remainingBytes;
    uint8_t aligmentInBytes = config->opsConfig.addrAligment.sectionCmd;
    status_t returnCode;
 
    returnCode = ftfx_check_mem_range(config, start, lengthInBytes, aligmentInBytes);
    if (returnCode)
    {
        return returnCode;
    }
 
    start = config->opsConfig.convertedAddress;
    blockSize = config->flashDesc.totalSize / config->flashDesc.blockCount;
 
    nextBlockStartAddress = ALIGN_UP(start, blockSize);
    if (nextBlockStartAddress == start)
    {
        nextBlockStartAddress += blockSize;
    }
 
    remainingBytes = lengthInBytes;
 
    while (remainingBytes)
    {
        uint32_t numberOfPhrases;
        uint32_t verifyLength = nextBlockStartAddress - start;
        if (verifyLength > remainingBytes)
        {
            verifyLength = remainingBytes;
        }
 
        numberOfPhrases = verifyLength / aligmentInBytes;
 
        /* Fill in verify section command parameters. */
        kFCCOBx[0] = BYTE2WORD_1_3(FTFx_VERIFY_SECTION, start);
        kFCCOBx[1] = BYTE2WORD_2_1_1(numberOfPhrases, margin, 0xFFU);
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
        if (returnCode)
        {
            return returnCode;
        }
 
        remainingBytes -= verifyLength;
        start += verifyLength;
        nextBlockStartAddress += blockSize;
    }
 
    return kStatus_FTFx_Success;
}

Referenced by FLEXNVM_DflashVerifyErase().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_VerifyEraseAll()

status_t FTFx_CMD_VerifyEraseAll	(	ftfx_config_t *	config,
		ftfx_margin_value_t	margin
	)

Verifies erasure of the entire flash at a specified margin level.

This function checks whether the flash is erased to the specified read margin level.

Parameters

config	A pointer to the storage for the driver runtime state.
margin	Read margin choice.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 895 of file fsl_ftfx_controller.c.

{
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* preparing passing parameter to verify all block command */
    kFCCOBx[0] = BYTE2WORD_1_1_2(FTFx_VERIFY_ALL_BLOCK, margin, 0xFFFFU);
 
    /* calling flash command sequence function to execute the command */
    return ftfx_command_sequence(config);
}

Referenced by FLEXNVM_VerifyEraseAll().

Here is the call graph for this function:

Here is the caller graph for this function:

FTFx_CMD_VerifyEraseAllExecuteOnlySegments()

status_t FTFx_CMD_VerifyEraseAllExecuteOnlySegments	(	ftfx_config_t *	config,
		ftfx_margin_value_t	margin
	)

Verifies whether the program flash execute-only segments have been erased to the specified read margin level.

Parameters

config	A pointer to the storage for the driver runtime state.
margin	Read margin choice.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 909 of file fsl_ftfx_controller.c.

{
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* preparing passing parameter to verify erase all execute-only segments command */
    kFCCOBx[0] = BYTE2WORD_1_1_2(FTFx_VERIFY_ALL_EXECUTE_ONLY_SEGMENT, margin, 0xFFFFU);
 
    /* calling flash command sequence function to execute the command */
    return ftfx_command_sequence(config);
}

Here is the call graph for this function:

FTFx_CMD_VerifyProgram()

status_t FTFx_CMD_VerifyProgram	(	ftfx_config_t *	config,
		uint32_t	start,
		uint32_t	lengthInBytes,
		const uint8_t *	expectedData,
		ftfx_margin_value_t	margin,
		uint32_t *	failedAddress,
		uint32_t *	failedData
	)

Verifies programming of the desired flash area at a specified margin level.

This function verifies the data programed in the flash memory using the Flash Program Check Command and compares it to the expected data for a given flash area as determined by the start address and length.

Parameters

config	A pointer to the storage for the driver runtime state.
start	The start address of the desired flash memory to be verified. Must be word-aligned.
lengthInBytes	The length, given in bytes (not words or long-words), to be verified. Must be word-aligned.
expectedData	A pointer to the expected data that is to be verified against.
margin	Read margin choice.
failedAddress	A pointer to the returned failing address.
failedData	A pointer to the returned failing data. Some derivatives do not include failed data as part of the FCCOBx registers. In this case, zeros are returned upon failure.

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.
kStatus_FTFx_AlignmentError	Parameter is not aligned with specified baseline.
kStatus_FTFx_AddressError	Address is out of range.
kStatus_FTFx_ExecuteInRamFunctionNotReady	Execute-in-RAM function is not available.
kStatus_FTFx_AccessError	Invalid instruction codes and out-of bounds addresses.
kStatus_FTFx_ProtectionViolation	The program/erase operation is requested to execute on protected areas.
kStatus_FTFx_CommandFailure	Run-time error during the command execution.

Definition at line 923 of file fsl_ftfx_controller.c.

{
    status_t returnCode;
    uint8_t aligmentInBytes = config->opsConfig.addrAligment.checkCmd;
    if (expectedData == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    returnCode = ftfx_check_mem_range(config, start, lengthInBytes, aligmentInBytes);
    if (returnCode)
    {
        return returnCode;
    }
 
    start = config->opsConfig.convertedAddress;
 
    while (lengthInBytes)
    {
        /* preparing passing parameter to program check the flash block */
        kFCCOBx[0] = BYTE2WORD_1_3(FTFx_PROGRAM_CHECK, start);
        kFCCOBx[1] = BYTE2WORD_1_3(margin, 0xFFFFFFU);
        kFCCOBx[2] = ftfx_read_word_from_byte_address((const uint8_t*)expectedData);
 
        /* calling flash command sequence function to execute the command */
        returnCode = ftfx_command_sequence(config);
 
        /* checking for the success of command execution */
        if (kStatus_FTFx_Success != returnCode)
        {
            if (failedAddress)
            {
                *failedAddress = start;
            }
            if (failedData)
            {
                *failedData = 0;
            }
            break;
        }
 
        lengthInBytes -= aligmentInBytes;
        expectedData += aligmentInBytes;
        start += aligmentInBytes;
    }
 
    return (returnCode);
}

Referenced by FLEXNVM_DflashVerifyProgram().

Here is the call graph for this function:

Here is the caller graph for this function:

ftfx_command_sequence()

static status_t ftfx_command_sequence ( ftfx_config_t *  config )

static

Internal function Flash command sequence. Called by driver APIs only.

FTFx Command Sequence.

This function is used to perform the command write sequence to the flash.

Parameters

driver

Pointer to storage for the driver runtime state.

Returns

An error code or kStatus_FTFx_Success

Definition at line 1187 of file fsl_ftfx_controller.c.

{
    uint8_t registerValue;
    
#if FTFx_DRIVER_IS_FLASH_RESIDENT
    /* clear RDCOLERR & ACCERR & FPVIOL flag in flash status register */
    FTFx->FSTAT = FTFx_FSTAT_RDCOLERR_MASK | FTFx_FSTAT_ACCERR_MASK | FTFx_FSTAT_FPVIOL_MASK;
 
    /* Since the value of ARM function pointer is always odd, but the real start address
     * of function memory should be even, that's why +1 operation exist. */
    callFtfxRunCommand_t callFtfxRunCommand = (callFtfxRunCommand_t)((uint32_t)config->runCmdFuncAddr + 1);
 
    /* We pass the ftfx_fstat address as a parameter to flash_run_comamnd() instead of using
     * pre-processed MICRO sentences or operating global variable in flash_run_comamnd()
     * to make sure that flash_run_command() will be compiled into position-independent code (PIC). */
    callFtfxRunCommand((FTFx_REG8_ACCESS_TYPE)(&FTFx->FSTAT));
#else
    /* clear RDCOLERR & ACCERR & FPVIOL flag in flash status register */
    FTFx->FSTAT = FTFx_FSTAT_RDCOLERR_MASK | FTFx_FSTAT_ACCERR_MASK | FTFx_FSTAT_FPVIOL_MASK;
 
    /* clear CCIF bit */
    FTFx->FSTAT = FTFx_FSTAT_CCIF_MASK;
 
    /* Check CCIF bit of the flash status register, wait till it is set.
     * IP team indicates that this loop will always complete. */
    while (!(FTFx->FSTAT & FTFx_FSTAT_CCIF_MASK))
    {
    }
#endif /* FTFx_DRIVER_IS_FLASH_RESIDENT */
 
    /* Check error bits */
    /* Get flash status register value */
    registerValue = FTFx->FSTAT;
 
    /* checking access error */
    if (registerValue & FTFx_FSTAT_ACCERR_MASK)
    {
        return kStatus_FTFx_AccessError;
    }
    /* checking protection error */
    else if (registerValue & FTFx_FSTAT_FPVIOL_MASK)
    {
        return kStatus_FTFx_ProtectionViolation;
    }
    /* checking MGSTAT0 non-correctable error */
    else if (registerValue & FTFx_FSTAT_MGSTAT0_MASK)
    {
        return kStatus_FTFx_CommandFailure;
    }
    else
    {
        return kStatus_FTFx_Success;
    }
}

Referenced by FTFx_CMD_Erase(), FTFx_CMD_EraseAll(), FTFx_CMD_EraseAllExecuteOnlySegments(), FTFx_CMD_EraseAllUnsecure(), FTFx_CMD_Program(), FTFx_CMD_ProgramOnce(), FTFx_CMD_ProgramPartition(), FTFx_CMD_ProgramSection(), FTFx_CMD_ReadOnce(), FTFx_CMD_ReadResource(), FTFx_CMD_SecurityBypass(), FTFx_CMD_SetFlexramFunction(), FTFx_CMD_SwapControl(), FTFx_CMD_VerifyErase(), FTFx_CMD_VerifyEraseAll(), FTFx_CMD_VerifyEraseAllExecuteOnlySegments(), and FTFx_CMD_VerifyProgram().

Here is the caller graph for this function:

ftfx_copy_run_command_to_ram()

static void ftfx_copy_run_command_to_ram ( uint32_t *  ftfxRunCommand )

static

Copy flash_run_command() to RAM.

Copy PIC of flash_run_command() to RAM.

Definition at line 1169 of file fsl_ftfx_controller.c.

{
    assert(sizeof(s_ftfxRunCommandFunctionCode) <= (kFTFx_RamFuncMaxSizeInWords * 4));
 
    /* Since the value of ARM function pointer is always odd, but the real start address
     * of function memory should be even, that's why +1 operation exist. */
    memcpy((uint8_t *)ftfxRunCommand, (const uint8_t *)s_ftfxRunCommandFunctionCode, sizeof(s_ftfxRunCommandFunctionCode));
}

Referenced by FTFx_API_Init().

Here is the caller graph for this function:

ftfx_init_ifr()

static status_t ftfx_init_ifr ( ftfx_config_t *  config )

static

Init IFR memory related info.

Definition at line 1117 of file fsl_ftfx_controller.c.

{
    if (config == NULL)
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
#if FSL_FEATURE_FLASH_IS_FTFA
    /* FTFA parts(eg. K80, KL80, L5K) support both 4-bytes and 8-bytes unit size */
    config->ifrDesc.feature.has4ByteIdxSupport = 1;
    config->ifrDesc.feature.has8ByteIdxSupport = 1;
    config->ifrDesc.idxInfo.mix8byteIdxStart = 0x10U;
    config->ifrDesc.idxInfo.mix8byteIdxEnd = 0x13U;
#elif FSL_FEATURE_FLASH_IS_FTFE
    /* FTFE parts(eg. K65, KE18) only support 8-bytes unit size */
    config->ifrDesc.feature.has4ByteIdxSupport = 0;
    config->ifrDesc.feature.has8ByteIdxSupport = 1;
#elif FSL_FEATURE_FLASH_IS_FTFL
    /* FTFL parts(eg. K20) only support 4-bytes unit size */
    config->ifrDesc.feature.has4ByteIdxSupport = 1;
    config->ifrDesc.feature.has8ByteIdxSupport = 0;
#endif
 
    config->ifrDesc.resRange.pflashIfrStart = 0x0000U;
    config->ifrDesc.resRange.versionIdSize = 0x08U;
#if FSL_FEATURE_FLASH_IS_FTFE
    config->ifrDesc.resRange.versionIdStart = 0x08U;
    config->ifrDesc.resRange.ifrMemSize = 0x0400U;
#else /* FSL_FEATURE_FLASH_IS_FTFL == 1 or FSL_FEATURE_FLASH_IS_FTFA = =1 */
    config->ifrDesc.resRange.versionIdStart = 0x00U;
    config->ifrDesc.resRange.ifrMemSize = 0x0100U;
#endif
 
#if FSL_FEATURE_FLASH_HAS_FLEX_NVM
    config->ifrDesc.resRange.dflashIfrStart = 0x800000U;
#endif
 
#if FSL_FEATURE_FLASH_HAS_SWAP_CONTROL_CMD
#if FSL_FEATURE_FLASH_IS_FTFE
    config->ifrDesc.resRange.pflashSwapIfrStart = 0x40000U;
#else /* FSL_FEATURE_FLASH_IS_FTFL == 1 or FSL_FEATURE_FLASH_IS_FTFA == 1 */
    config->ifrDesc.resRange.pflashSwapIfrStart = config->flashDesc.totalSize / 4;
#endif
#endif /* FSL_FEATURE_FLASH_HAS_SWAP_CONTROL_CMD */
 
    return kStatus_FTFx_Success;
}

Referenced by FTFx_API_Init().

Here is the caller graph for this function:

ftfx_read_word_from_byte_address()

static uint32_t ftfx_read_word_from_byte_address ( const uint8_t *  src )

static

Reads word from byte address.

Definition at line 1282 of file fsl_ftfx_controller.c.

{
    uint32_t word = 0;
 
    if (!((uint32_t)src % 4))
    {
        word = *(const uint32_t *)src;
    }
    else
    {
        for (uint32_t i = 0; i < 4; i++)
        {
            word |= (uint32_t)(*src) << (i * 8);
            src++;
        }
    }
 
   return word;
}

Referenced by FTFx_CMD_Program(), FTFx_CMD_ProgramOnce(), and FTFx_CMD_VerifyProgram().

Here is the caller graph for this function:

FTFx_REG_GetSecurityState()

status_t FTFx_REG_GetSecurityState	(	ftfx_config_t *	config,
		ftfx_security_state_t *	state
	)

Returns the security state via the pointer passed into the function.

This function retrieves the current flash security status, including the security enabling state and the backdoor key enabling state.

Parameters

config	A pointer to storage for the driver runtime state.
state	A pointer to the value returned for the current security status code:

Return values

kStatus_FTFx_Success	API was executed successfully.
kStatus_FTFx_InvalidArgument	An invalid argument is provided.

Definition at line 1010 of file fsl_ftfx_controller.c.

{
    /* store data read from flash register */
    uint8_t registerValue;
 
    if ((config == NULL) || (state == NULL))
    {
        return kStatus_FTFx_InvalidArgument;
    }
 
    /* Get flash security register value */
    registerValue = FTFx->FSEC;
 
    /* check the status of the flash security bits in the security register */
    if (kFTFx_FsecRegCode_SEC_Unsecured == (registerValue & FTFx_FSEC_SEC_MASK))
    {
        /* Flash in unsecured state */
        *state = kFTFx_SecurityStateNotSecure;
    }
    else
    {
        /* Flash in secured state
         * check for backdoor key security enable bit */
        if (kFTFx_FsecRegCode_KEYEN_Enabled == (registerValue & FTFx_FSEC_KEYEN_MASK))
        {
            /* Backdoor key security enabled */
            *state = kFTFx_SecurityStateBackdoorEnabled;
        }
        else
        {
            /* Backdoor key security disabled */
            *state = kFTFx_SecurityStateBackdoorDisabled;
        }
    }
 
    return (kStatus_FTFx_Success);
}

Referenced by FLEXNVM_GetSecurityState().

Here is the call graph for this function:

Here is the caller graph for this function:

ftfx_write_word_to_byte_address()

static void ftfx_write_word_to_byte_address ( uint8_t *  dst, uint32_t  word  )

static

Writes word to byte address.

Definition at line 1303 of file fsl_ftfx_controller.c.

{
    if (!((uint32_t)dst % 4))
    {
        *(uint32_t *)dst = word;
    }
    else
    {
        for (uint32_t i = 0; i < 4; i++)
        {
            *dst = (uint8_t)((word >> (i * 8)) & 0xFFU);
            dst++;
        }
    }
}

Referenced by FTFx_CMD_ReadOnce(), and FTFx_CMD_ReadResource().

Here is the caller graph for this function:

Variable Documentation

kDflashDensities

const uint32_t kDflashDensities[16]

static

Initial value:

= {
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0000,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0001,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0010,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0011,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0100,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0101,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0110,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0111,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1000,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1001,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1010,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1011,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1100,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1101,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1110,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1111
}

Table of dflash sizes.

Definition at line 216 of file fsl_ftfx_controller.c.

                                             {
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0000,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0001,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0010,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0011,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0100,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0101,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0110,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_0111,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1000,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1001,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1010,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1011,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1100,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1101,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1110,
    FSL_FEATURE_FLASH_FLEX_NVM_DFLASH_SIZE_FOR_DEPART_1111
};

Referenced by FTFx_API_UpdateFlexnvmPartitionStatus().

kEepromDensities

const uint16_t kEepromDensities[16]

static

Initial value:

= {
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0000,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0001,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0010,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0011,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0100,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0101,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0110,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0111,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1000,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1001,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1010,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1011,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1100,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1101,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1110,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1111
}

Table of eeprom sizes.

Definition at line 197 of file fsl_ftfx_controller.c.

                                             {
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0000,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0001,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0010,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0011,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0100,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0101,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0110,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_0111,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1000,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1001,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1010,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1011,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1100,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1101,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1110,
    FSL_FEATURE_FLASH_FLEX_NVM_EEPROM_SIZE_FOR_EEESIZE_1111
};

Referenced by FTFx_API_UpdateFlexnvmPartitionStatus().

kFCCOBx

volatile uint32_t* const kFCCOBx = (volatile uint32_t *)&FTFx_FCCOB3_REG

static

Access to FTFx Registers.

Definition at line 193 of file fsl_ftfx_controller.c.

Referenced by FTFx_CMD_Erase(), FTFx_CMD_EraseAll(), FTFx_CMD_EraseAllExecuteOnlySegments(), FTFx_CMD_EraseAllUnsecure(), FTFx_CMD_Program(), FTFx_CMD_ProgramOnce(), FTFx_CMD_ProgramPartition(), FTFx_CMD_ProgramSection(), FTFx_CMD_ReadOnce(), FTFx_CMD_ReadResource(), FTFx_CMD_SecurityBypass(), FTFx_CMD_SetFlexramFunction(), FTFx_CMD_SwapControl(), FTFx_CMD_VerifyErase(), FTFx_CMD_VerifyEraseAll(), FTFx_CMD_VerifyEraseAllExecuteOnlySegments(), and FTFx_CMD_VerifyProgram().

s_ftfxRunCommand

uint32_t s_ftfxRunCommand[kFTFx_RamFuncMaxSizeInWords]

static

A static buffer used to hold flash_run_command()

Definition at line 188 of file fsl_ftfx_controller.c.

Referenced by FTFx_API_Init().

s_ftfxRunCommandFunctionCode

const uint16_t s_ftfxRunCommandFunctionCode[]

static

Initial value:

= {
    0x2180, 
    0x7001, 
    
    0x7802, 
    0x420a, 
    0xd0fc, 
    0x4770  
}

Position independent code of flash_run_command()

Note1: The prototype of C function is shown as below:

void flash_run_command(FTFx_REG8_ACCESS_TYPE ftfx_fstat)
{
    // clear CCIF bit
    *ftfx_fstat = FTFx_FSTAT_CCIF_MASK;
 
    // Check CCIF bit of the flash status register, wait till it is set.
    // IP team indicates that this loop will always complete.
    while (!((*ftfx_fstat) & FTFx_FSTAT_CCIF_MASK))
    {
    }
}

Note2: The binary code is generated by IAR 7.70.1

Definition at line 177 of file fsl_ftfx_controller.c.

                                                       {
    0x2180, /* MOVS  R1, #128 ; 0x80 */
    0x7001, /* STRB  R1, [R0] */
    /* @4: */
    0x7802, /* LDRB  R2, [R0] */
    0x420a, /* TST   R2, R1 */
    0xd0fc, /* BEQ.N @4 */
    0x4770  /* BX    LR */
};

Referenced by ftfx_copy_run_command_to_ram().

Go to the source code of this file.