Typedefs
typedef uint32_t	flashdata_t

Functions
void	flashPrintStatus (void)

static bool	flashInit (void)

bool	flashUnlock (void)

bool	flashLock (void)

static int	alignToWord (int v)

int	intFlashErase (flashaddr_t address, size_t size)
	Erase the sectors containing the span of `size` bytes starting at `address`.

int	intFlashWrite (flashaddr_t address, const char *buffer, size_t size)
	Copy data from a `buffer` to the flash memory.

bool	intFlashIsErased (flashaddr_t address, size_t size)
	Check if the `size` bytes of flash memory starting at `address` are erased.

bool	intFlashCompare (flashaddr_t address, const char *buffer, size_t size)
	Check if the data in `buffer` are identical to the one in flash memory.

int	intFlashRead (flashaddr_t source, char *destination, size_t size)
	Copy data from the flash memory to a `destination`.

Variables
static bool	wasInit = false

static bool	isLocked = true

static bool	isInitializing = false

static flexnvm_config_t	flashCfg

static status_t	initStatus = -1

static status_t	protectStatus = -1

static status_t	securityStatus = -1

static uint8_t	protectValue = 0

static ftfx_security_state_t	sstate

static kinetis_clock_type_e	savedClockType = KINETIS_DEFAULT_CLK

Typedef Documentation

◆ flashdata_t

typedef uint32_t flashdata_t

Definition at line 19 of file flash_int.cpp.

Function Documentation

◆ alignToWord()

static int alignToWord ( int v )

static

Definition at line 111 of file flash_int.cpp.

                              {
    return (v + FSL_FEATURE_FLASH_FLEX_NVM_SECTOR_CMD_ADDRESS_ALIGMENT - 1) & ~(FSL_FEATURE_FLASH_FLEX_NVM_SECTOR_CMD_ADDRESS_ALIGMENT - 1);
}

◆ flashInit()

static bool flashInit ( void )

static

Definition at line 56 of file flash_int.cpp.

                            {
    isInitializing = true;
    
    memset(&flashCfg, 0, sizeof(flashCfg));
    initStatus = FLEXNVM_Init(&flashCfg);
    protectStatus = FLEXNVM_DflashGetProtection(&flashCfg, &protectValue);
    securityStatus = FLEXNVM_GetSecurityState(&flashCfg, &sstate);
 
    wasInit = true;
    isInitializing = false;
 
#ifdef KINETIS_FLASH_DEBUG
    flashPrintStatus();
#endif /* KINETIS_FLASH_DEBUG */
 
    return (initStatus == kStatus_FTFx_Success);
}

Referenced by flashUnlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flashLock()

bool flashLock ( void )

Definition at line 96 of file flash_int.cpp.

                     {
    // this is strictly non-reentrant function!
    if (isLocked) {
        return false;   // already locked
    }
 
    // restore clock
    ke1xf_clock_init(savedClockType);
 
    isLocked = true;
//  chSysUnconditionalUnlock();
 
    return true;
}

Here is the call graph for this function:

◆ flashPrintStatus()

void flashPrintStatus ( void )

Definition at line 35 of file flash_int.cpp.

                            {
    debugLog("* flashInit status=%d\r\n", initStatus);
    debugLog("* FLEXNVM_DflashGetProtection status=%d prot=%d\r\n", protectStatus, protectValue);
    debugLog("* FLEXNVM_GetSecurityState status=%d security=0x%08x\r\n", securityStatus, sstate);
 
    uint32_t dflashBlockBase = 0;
    uint32_t dflashTotalSize = 0;
    uint32_t dflashSectorSize = 0;
 
    /* Get flash properties*/
    FLEXNVM_GetProperty(&flashCfg, kFLEXNVM_PropertyDflashBlockBaseAddr, &dflashBlockBase);
    FLEXNVM_GetProperty(&flashCfg, kFLEXNVM_PropertyDflashTotalSize, &dflashTotalSize);
    FLEXNVM_GetProperty(&flashCfg, kFLEXNVM_PropertyDflashSectorSize, &dflashSectorSize);
 
    debugLog("Data Flash Base Address: (0x%x)\r\n", dflashBlockBase);
    debugLog("Data Flash Total Size:\t%d KB, Hex: (0x%x)\r\n", (dflashTotalSize / 1024), dflashTotalSize);
    debugLog("Data Flash Sector Size:\t%d KB, Hex: (0x%x)\r\n", (dflashSectorSize / 1024), dflashSectorSize);
}

Referenced by flashInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flashUnlock()

bool flashUnlock ( void )

Definition at line 74 of file flash_int.cpp.

                       {
//  chSysUnconditionalLock();
    // this is strictly non-reentrant function!
    if (!isLocked) {
//      chSysUnconditionalUnlock();
        return false;   // already unlocked
    }
    isLocked = false;
    
    savedClockType = ke1xf_clock_get_current_type();
    // flash commands won't work in HSRUN clock mode
    // we set a lower frequency clock
    ke1xf_clock_init(kinetis_clock_int_osc_run);
    
    // before any flash access function, we should have called init() first (but not from init() itself)
    if (!isInitializing && !wasInit) {
        flashInit();
    }
 
    return true;
}

Here is the call graph for this function:

◆ intFlashCompare()

bool intFlashCompare	(	flashaddr_t	address,
		const char *	buffer,
		size_t	size
	)

Check if the data in buffer are identical to the one in flash memory.

Parameters

address	First address in flash memory to be checked.
buffer	Buffer containing the data to compare.
size	Size of `buffer` in bytes.

Returns: TRUE if the flash memory and the buffer contain identical data.; FALSE if the flash memory and the buffer don't contain identical data.

Definition at line 173 of file flash_int.cpp.

                                                                           {
#if 0
    uint32_t failAddr = 0, failDat = 0;
    status_t status = FLEXNVM_DflashVerifyProgram(&flashCfg, address, size, (const uint8_t *)buffer, 
                                             kFTFx_MarginValueUser, &failAddr, &failDat);
    return (status == kStatus_FTFx_Success);
#endif
    /* For efficiency, compare flashdata_t values as much as possible,
     * then, fallback to byte per byte comparison. */
    while (size >= sizeof(flashdata_t)) {
        if (*(volatile flashdata_t*) address != *(flashdata_t*) buffer)
            return FALSE;
        address += sizeof(flashdata_t);
        buffer += sizeof(flashdata_t);
        size -= sizeof(flashdata_t);
    }
    while (size > 0) {
        if (*(volatile char*) address != *buffer)
            return FALSE;
        ++address;
        ++buffer;
        --size;
    }
 
    return TRUE;
}

Here is the call graph for this function:

◆ intFlashErase()

int intFlashErase	(	flashaddr_t	address,
		size_t	size
	)

Erase the sectors containing the span of size bytes starting at address.

Warning: If address doesn't match the beginning of a sector, the data contained between the beginning of the sector and address will be erased too. The same applies for data contained at address + size up to the end of the sector.

Parameters

address	Starting address of the span in flash memory.
size	Size of the span in bytes.

Returns: FLASH_RETURN_SUCCESS No error erasing the flash memory.; FLASH_RETURN_BAD_FLASH Flash cell error.; FLASH_RETURN_NO_PERMISSION Access denied.

Definition at line 115 of file flash_int.cpp.

                                                    {
    if (!flashUnlock())
        return FLASH_RETURN_NO_PERMISSION;
        
    flashaddr_t sizeAligned = alignToWord(size);
    status_t status = FLEXNVM_DflashErase(&flashCfg, address, sizeAligned, kFTFx_ApiEraseKey);
 
    flashLock();
 
#ifdef KINETIS_FLASH_DEBUG
    debugLog("* flashErase(addr=%08x siz=%d sizeAligned=%d)=%d\r\n", address, size, sizeAligned, status);
#endif /* KINETIS_FLASH_DEBUG */
 
    if (status == kStatus_FTFx_Success)
        return FLASH_RETURN_SUCCESS;
    return -(int)status;
}

◆ intFlashIsErased()

bool intFlashIsErased	(	flashaddr_t	address,
		size_t	size
	)

Check if the size bytes of flash memory starting at address are erased.

Note: If the memory is erased, one can write data into it safely.

Parameters

address	First address in flash memory to be checked.
size	Size of the memory space to be checked in bytes.

Returns: TRUE Memory is already erased.; FALSE Memory is not erased.

Definition at line 153 of file flash_int.cpp.

                                                        {
    /* Check for default set bits in the flash memory
     * For efficiency, compare flashdata_t values as much as possible,
     * then, fallback to byte per byte comparison. */
    while (size >= sizeof(flashdata_t)) {
        if (*(volatile flashdata_t*) address != (flashdata_t) (-1)) // flashdata_t being unsigned, -1 is 0xFF..FF
            return false;
        address += sizeof(flashdata_t);
        size -= sizeof(flashdata_t);
    }
    while (size > 0) {
        if (*(char*) address != 0xFF)
            return false;
        ++address;
        --size;
    }
 
    return TRUE;
}

◆ intFlashRead()

int intFlashRead	(	flashaddr_t	source,
		char *	destination,
		size_t	size
	)

Copy data from the flash memory to a destination.

Warning: The destination must be at least size bytes long.

Parameters

source	First address of the flash memory to be copied.
destination	Buffer to copy to.
size	Size of the data to be copied in bytes.

Returns: FLASH_RETURN_SUCCESS if successfully copied.

Definition at line 200 of file flash_int.cpp.

                                                                     {
    memcpy(destination, (char*) source, size);
    return FLASH_RETURN_SUCCESS;
}

◆ intFlashWrite()

int intFlashWrite	(	flashaddr_t	address,
		const char *	buffer,
		size_t	size
	)

Copy data from a buffer to the flash memory.

Warning: The flash memory area receiving the data must be erased.; The buffer must be at least size bytes long.

Parameters

address	First address in the flash memory where to copy the data to.
buffer	Buffer containing the data to copy.
size	Size of the data to be copied in bytes.

Returns: FLASH_RETURN_SUCCESS No error.; FLASH_RETURN_NO_PERMISSION Access denied.

Definition at line 133 of file flash_int.cpp.

                                                                        {
    if (!flashUnlock())
        return FLASH_RETURN_NO_PERMISSION;
 
    //FLEXNVM_DflashSetProtection(&flashCfg, 0xff);
 
    flashaddr_t sizeAligned = alignToWord(size);
    status_t status = FLEXNVM_DflashProgram(&flashCfg, address, (uint8_t *)buffer, sizeAligned);
 
    flashLock();
 
#ifdef KINETIS_FLASH_DEBUG
    debugLog("* flashWrite(addr=%08x siz=%d sizeAligned=%d)=%d\r\n", address, size, sizeAligned, status);
#endif /* KINETIS_FLASH_DEBUG */
 
    if (status == kStatus_FTFx_Success)
        return FLASH_RETURN_SUCCESS;
    return -(int)status;
}