Typedefs
typedef uint32_t	flashdata_t

typedef uintptr_t	flashaddr_t
	Address in the flash memory.

typedef uint8_t	flashsector_t
	Index of a sector.

Functions
size_t	flashSectorSize (flashsector_t sector)
	Get the size of `sector`.

uintptr_t	getFlashAddrFirstCopy (void)

uintptr_t	getFlashAddrSecondCopy (void)

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

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`.

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

Typedef Documentation

◆ flashaddr_t

typedef uintptr_t flashaddr_t

Address in the flash memory.

Definition at line 86 of file flash_int.h.

◆ flashdata_t

typedef uint8_t flashdata_t

Definition at line 54 of file flash_int.h.

◆ flashsector_t

typedef uint8_t flashsector_t

Index of a sector.

Definition at line 89 of file flash_int.h.

Function Documentation

◆ flashSectorSize()

size_t flashSectorSize ( flashsector_t sector )

Get the size of sector.

Returns: sector size in bytes.

Definition at line 237 of file mpu_util.cpp.

                                             {
    // sectors 0..11 are the 1st memory bank (1Mb), and 12..23 are the 2nd (the same structure).
    if (sector <= 3 || (sector >= 12 && sector <= 15))
        return 16 * 1024;
    else if (sector == 4 || sector == 16)
        return 64 * 1024;
    else if ((sector >= 5 && sector <= 11) || (sector >= 17 && sector <= 23))
        return 128 * 1024;
    return 0;
}

Referenced by flashSectorSize(), intFlashSectorBegin(), and intFlashSectorErase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFlashAddrFirstCopy()

uintptr_t getFlashAddrFirstCopy ( void )

Flex Non Volatile Memory is faster than flash It also has smaller pages so it takes less time to erase

There is no remote access to FlexNVM meaning that we cannot erase settings externally

Definition at line 248 of file mpu_util.cpp.

                                  {
    return FLASH_ADDR;
}

Referenced by getFlashAddrSecondCopy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFlashAddrSecondCopy()

uintptr_t getFlashAddrSecondCopy ( void )

Definition at line 252 of file mpu_util.cpp.

                                   {
    return FLASH_ADDR_SECOND_COPY;
}

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 109 of file flash_int.cpp.

                                                                           {
    /* 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;
}

Referenced by backupRamFlush(), and FlashErase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 89 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;
}

Referenced by FlashErase(), FlashVerifyChecksum(), and intFlashSectorErase().

Here is the caller graph for this function:

◆ 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 130 of file flash_int.cpp.

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

Referenced by backupInit().

Here is the caller graph for this function:

◆ 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 370 of file flash_int.cpp.

                                                                        {
    int ret = FLASH_RETURN_SUCCESS;
 
    /* Unlock flash for write access */
    if (intFlashUnlock() == HAL_FAILED)
        return FLASH_RETURN_NO_PERMISSION;
 
    /* Wait for any busy flags */
    intFlashWaitWhileBusy();
 
    /* Setup parallelism before any program/erase */
    FLASH->CR &= ~FLASH_CR_PSIZE_MASK;
    FLASH->CR |= FLASH_CR_PSIZE_VALUE;
 
    /* Check if the flash address is correctly aligned */
    size_t alignOffset = address % sizeof(flashdata_t);
//  print("flash alignOffset=%d\r\n", alignOffset);
    if (alignOffset != 0) {
        /* Not aligned, thus we have to read the data in flash already present
         * and update them with buffer's data */
 
        /* Align the flash address correctly */
        flashaddr_t alignedFlashAddress = address - alignOffset;
 
        /* Read already present data */
        flashdata_t tmp = *(volatile flashdata_t*) alignedFlashAddress;
 
        /* Compute how much bytes one must update in the data read */
        size_t chunkSize = sizeof(flashdata_t) - alignOffset;
        if (chunkSize > size)
            chunkSize = size; // this happens when both address and address + size are not aligned
 
        /* Update the read data with buffer's data */
        memcpy((char*) &tmp + alignOffset, buffer, chunkSize);
 
        /* Write the new data in flash */
        ret = intFlashWriteData(alignedFlashAddress, tmp);
        if (ret != FLASH_RETURN_SUCCESS)
            goto exit;
 
        /* Advance */
        address += chunkSize;
        buffer += chunkSize;
        size -= chunkSize;
    }
 
    /* Now, address is correctly aligned. One can copy data directly from
     * buffer's data to flash memory until the size of the data remaining to be
     * copied requires special treatment. */
    while (size >= sizeof(flashdata_t)) {
//      print("flash write size=%d\r\n", size);
        ret = intFlashWriteData(address, *(const flashdata_t*) buffer);
        if (ret != FLASH_RETURN_SUCCESS)
            goto exit;
        address += sizeof(flashdata_t);
        buffer += sizeof(flashdata_t);
        size -= sizeof(flashdata_t);
    }
 
    /* Now, address is correctly aligned, but the remaining data are to
     * small to fill a entier flashdata_t. Thus, one must read data already
     * in flash and update them with buffer's data before writing an entire
     * flashdata_t to flash memory. */
    if (size > 0) {
        flashdata_t tmp = *(volatile flashdata_t*) address;
        memcpy(&tmp, buffer, size);
        ret = intFlashWriteData(address, tmp);
        if (ret != FLASH_RETURN_SUCCESS)
            goto exit;
    }
 
exit:
    /* Lock flash again */
    intFlashLock()
    ;
 
    return ret;
}