flash_int.cpp File Reference

Detailed Description

Lower-level code related to internal flash memory.

http://www.chibios.com/forum/viewtopic.php?f=8&t=820 https://github.com/tegesoft/flash-stm32f407

Definition in file flash_int.cpp.

Functions
flashaddr_t	intFlashSectorBegin (flashsector_t sector)
flashaddr_t	intFlashSectorEnd (flashsector_t sector)
flashsector_t	intFlashSectorAt (flashaddr_t address)
static void	intFlashClearErrors ()
static int	intFlashCheckErrors ()
static bool	intFlashUnlock (void)
	Unlock the flash memory for write access.
static bool	isDualBank (void)
static int	intFlashSectorErase (flashsector_t sector)
	Erase the flash sector.
static void	intFlashSetPVD ()
static bool	intFlashGetPVDStatus ()
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.
static int	intFlashWriteData (flashaddr_t address, const flashdata_t data)

Function Documentation

intFlashCheckErrors()

static int intFlashCheckErrors ( )

static

Definition at line 89 of file flash_int.cpp.

                                 {
    uint32_t sr = FLASH_SR;
 
#ifdef FLASH_SR_OPERR
    if (sr & FLASH_SR_OPERR)
        return FLASH_RETURN_OPERROR;
#endif
    if (sr & FLASH_SR_WRPERR)
        return FLASH_RETURN_WPERROR;
#ifdef FLASH_SR_PGAERR
    if (sr & FLASH_SR_PGAERR)
        return FLASH_RETURN_ALIGNERROR;
#endif
#ifdef FLASH_SR_PGPERR
    if (sr & FLASH_SR_PGPERR)
        return FLASH_RETURN_PPARALLERROR;
#endif
#ifdef FLASH_SR_ERSERR
    if (sr & FLASH_SR_ERSERR)
        return FLASH_RETURN_ESEQERROR;
#endif
#ifdef FLASH_SR_PGSERR
    if (sr & FLASH_SR_PGSERR)
        return FLASH_RETURN_PSEQERROR;
#endif
#ifdef FLASH_SR_RDSERR
    if (sr & FLASH_SR_RDSERR)
        return FLASH_RETURN_SECURITYERROR;
#endif
#ifdef FLASH_SR_RDPERR
    if (sr & FLASH_SR_RDPERR)
        return FLASH_RETURN_SECURITYERROR;
#endif
#ifdef FLASH_SR_WRPERR
    if (sr & FLASH_SR_WRPERR)
        return FLASH_RETURN_SECURITYERROR;
#endif
#ifdef FLASH_SR_CRCRDERR
    if (sr & FLASH_SR_CRCRDERR)
        return FLASH_RETURN_CRCERROR;
#endif
 
    return FLASH_RETURN_SUCCESS;
}

Referenced by intFlashSectorErase(), and intFlashWriteData().

Here is the caller graph for this function:

intFlashClearErrors()

static void intFlashClearErrors ( )

static

Definition at line 80 of file flash_int.cpp.

                                  {
#ifdef STM32H7XX
    FLASH_CCR = 0xffffffff;
#else
    FLASH_SR = 0x0000ffff;
#endif
    __DSB();
}

Referenced by intFlashSectorErase(), and intFlashWriteData().

Here is the caller 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 319 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;
}

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

                                                    {
    flashaddr_t endAddress = address + size - 1;
    while (address <= endAddress) {
        flashsector_t sector = intFlashSectorAt(address);
        int err = intFlashSectorErase(sector);
        if (err != FLASH_RETURN_SUCCESS)
            return err;
        address = intFlashSectorEnd(sector);
    }
 
    return FLASH_RETURN_SUCCESS;
}

Referenced by backupRamFlush(), and FlashErase().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashGetPVDStatus()

static bool intFlashGetPVDStatus ( )

static

Definition at line 270 of file flash_int.cpp.

                                   {
    /* Return true if Vdd is higher then selected threshold */
#if defined(STM32F4XX)
    return !(PWR->CSR & PWR_CSR_PVDO);
#else
    return !(PWR->CSR1 & PWR_CSR1_PVDO);
#endif
}

Referenced by intFlashWrite().

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

                                                        {
#if CORTEX_MODEL == 7
    // If we have a cache, invalidate the relevant cache lines.
    // They may still contain old data, leading us to believe that the
    // flash erase failed.
    SCB_InvalidateDCache_by_Addr((uint32_t*)address, size);
#endif
 
    /* 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(), and FlashVerifyChecksum().

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

                                                                     {
#if CORTEX_MODEL == 7
    // If we have a cache, invalidate the relevant cache lines.
    // They may still contain old data, leading us to read invalid data.
    SCB_InvalidateDCache_by_Addr((uint32_t*)source, size);
#endif
 
    memcpy(destination, (char*) source, size);
    return FLASH_RETURN_SUCCESS;
}

Referenced by backupInit().

Here is the caller graph for this function:

intFlashSectorAt()

flashsector_t intFlashSectorAt

(

flashaddr_t

address

)

Definition at line 73 of file flash_int.cpp.

                                                    {
    flashsector_t sector = 0;
    while (address >= intFlashSectorEnd(sector))
        ++sector;
    return sector;
}

Referenced by intFlashErase().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashSectorBegin()

flashaddr_t intFlashSectorBegin

(

flashsector_t

sector

)

Definition at line 60 of file flash_int.cpp.

                                                      {
    flashaddr_t address = FLASH_BASE;
    while (sector > 0) {
        --sector;
        address += flashSectorSize(sector);
    }
    return address;
}

Referenced by intFlashSectorEnd(), and intFlashSectorErase().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashSectorEnd()

flashaddr_t intFlashSectorEnd

(

flashsector_t

sector

)

Definition at line 69 of file flash_int.cpp.

                                                    {
    return intFlashSectorBegin(sector + 1);
}

Referenced by intFlashErase(), and intFlashSectorAt().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashSectorErase()

static int intFlashSectorErase ( flashsector_t  sector )

static

Erase the flash sector.

The sector is checked for errors after erase.

Note

The sector is deleted regardless of its current state.

Parameters

sector

Sector which is going to be erased.

Returns

FLASH_RETURN_SUCCESS No error erasing the sector.

FLASH_RETURN_BAD_FLASH Flash cell error.

FLASH_RETURN_NO_PERMISSION Access denied.

Definition at line 180 of file flash_int.cpp.

                                                     {
    int ret;
    uint8_t sectorRegIdx = sector;
#ifdef STM32F7XX
    // On dual bank STM32F7, sector index doesn't match register value.
    // High bit indicates bank, low 4 bits indicate sector within bank.
    // Since each bank has 12 sectors, increment second-bank sector idx
    // by 4 so that the first sector of the second bank (12) ends up with
    // index 16 (0b10000)
    if (isDualBank() && sectorRegIdx >= 12) {
        sectorRegIdx -= 12;
        /* bit 4 defines bank.
         * Sectors starting from 12 are in bank #2 */
        sectorRegIdx |= 0x10;
    }
#endif
 
    /* Unlock flash for write access */
    if (intFlashUnlock() == HAL_FAILED)
        return FLASH_RETURN_NO_PERMISSION;
 
    /* Wait for any busy flags. */
    intFlashWaitWhileBusy();
 
    /* Clearing error status bits.*/
    intFlashClearErrors();
 
    /* Setup parallelism before any program/erase */
    FLASH_CR &= ~FLASH_CR_PSIZE_MASK;
    FLASH_CR |= FLASH_CR_PSIZE_VALUE;
 
    /* Start deletion of sector.
     * SNB(4:1) is defined as:
     * 00000 sector 0
     * 00001 sector 1
     * ...
     * 01011 sector 11 (the end of 1st bank, 1Mb border)
     * 10000 sector 12 (start of 2nd bank)
     * ...
     * 11011 sector 23 (the end of 2nd bank, 2Mb border)
     * others not allowed */
    FLASH_CR &= ~FLASH_CR_SNB_Msk;
    FLASH_CR |= (sectorRegIdx << FLASH_CR_SNB_Pos) & FLASH_CR_SNB_Msk;
    /* sector erase */
    FLASH_CR |= FLASH_CR_SER;
    /* start erase operation */
    FLASH_CR |= FLASH_CR_STRT;
 
    /* Wait until it's finished. */
    intFlashWaitWhileBusy();
 
    /* Sector erase flag does not clear automatically. */
    FLASH_CR &= ~FLASH_CR_SER;
 
    /* Lock flash again */
    intFlashLock()
    ;
 
    ret = intFlashCheckErrors();
    if (ret != FLASH_RETURN_SUCCESS)
        return ret;
 
    /* Check deleted sector for errors */
    if (intFlashIsErased(intFlashSectorBegin(sector), flashSectorSize(sector)) == FALSE)
        return FLASH_RETURN_BAD_FLASH; /* Sector is not empty despite the erase cycle! */
 
    /* Successfully deleted sector */
    return FLASH_RETURN_SUCCESS;
}

Referenced by intFlashErase().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashSetPVD()

static void intFlashSetPVD ( )

static

Definition at line 251 of file flash_int.cpp.

                             {
#if defined(STM32F4XX)
    /* Set threshold */
    PWR->CR = (PWR->CR & ~PWR_CR_PLS_Msk) | PWR_CR_PLS_VALUE;
    /* Enable PVD */
    PWR->CR |= PWR_CR_PVDE;
#elif defined(STM32F7XX)
    /* Set threshold */
    PWR->CR1 = (PWR->CR1 & ~PWR_CR1_PLS_Msk) | PWR_CR1_PLS_VALUE;
    /* Enable PVD */
    PWR->CR1 |= PWR_CR1_PVDE;
#elif defined(STM32H7XX)
    /* Set threshold */
    PWR->CR1 = (PWR->CR1 & ~PWR_CR1_PLS_Msk) | PWR_CR1_PLS_VALUE;
    /* Enable PVD */
    PWR->CR1 |= PWR_CR1_PVDEN;
#endif
}

Referenced by intFlashWrite().

Here is the caller graph for this function:

intFlashUnlock()

static bool intFlashUnlock ( void  )

static

Unlock the flash memory for write access.

Returns

HAL_SUCCESS Unlock was successful.

HAL_FAILED Unlock failed.

Definition at line 139 of file flash_int.cpp.

                                 {
    /* Check if unlock is really needed */
    if (!(FLASH_CR & FLASH_CR_LOCK))
        return HAL_SUCCESS;
 
    /* Write magic unlock sequence */
    FLASH_KEYR = 0x45670123;
    FLASH_KEYR = 0xCDEF89AB;
 
    /* Check if unlock was successful */
    if (FLASH_CR & FLASH_CR_LOCK)
        return HAL_FAILED;
    return HAL_SUCCESS;
}

Referenced by intFlashSectorErase(), and intFlashWrite().

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

                                                                        {
    intFlashSetPVD();
    if (!intFlashGetPVDStatus()) {
        return FLASH_RETURN_LOWVOLTAGEERROR;
    }
 
    /* Unlock flash for write access */
    if (intFlashUnlock() == HAL_FAILED)
        return FLASH_RETURN_NO_PERMISSION;
 
    /* Wait for any busy flags */
    intFlashWaitWhileBusy();
 
    /* Setup parallelism before program */
    FLASH_CR &= ~FLASH_CR_PSIZE_MASK;
    FLASH_CR |= FLASH_CR_PSIZE_VALUE;
 
    // Round up to the next number of full 32 byte words
    size_t flashWordCount = (size - 1) / 32 + 1;
 
    // Read units of flashdata_t from the buffer, writing to flash
    const flashdata_t* pRead = (const flashdata_t*)buffer;
    flashdata_t* pWrite = (flashdata_t*)address;
 
    for (size_t word = 0; word < flashWordCount; word++) {
        if (!intFlashGetPVDStatus()) {
            intFlashLock();
            return FLASH_RETURN_LOWVOLTAGEERROR;
        }
 
        /* Enter flash programming mode */
        FLASH_CR |= FLASH_CR_PG;
 
        // Flush pipelines
        __ISB();
        __DSB();
 
        static_assert(sizeof(*pWrite) == 4, "Driver supports only 32bit PSIZE");
 
        // Write 32 bytes/256bits
        for (size_t i = 0; i < 8; i++) {
            *pWrite++ = *pRead++;
        }
 
        // Flush pipelines
        __ISB();
        __DSB();
 
        /* Wait for completion */
        intFlashWaitWhileBusy();
 
        /* Exit flash programming mode */
        FLASH_CR &= ~FLASH_CR_PG;
 
        // Flush pipelines
        __ISB();
        __DSB();
    }
 
    /* Lock flash again */
    intFlashLock();
 
    return FLASH_RETURN_SUCCESS;
}

Referenced by backupInit(), backupRamFlush(), FlashBufferFlush(), and FlashWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

intFlashWriteData()

static int intFlashWriteData ( flashaddr_t  address, const flashdata_t  data  )

static

Definition at line 418 of file flash_int.cpp.

                                                                          {
    /* Clearing error status bits.*/
    intFlashClearErrors();
 
    /* Enter flash programming mode */
    FLASH->CR |= FLASH_CR_PG;
 
    /* Write the data */
    *(flashdata_t*) address = data;
 
    // Cortex-M7 (STM32F7/H7) can execute out order - need to force a full flush
    // so that we actually wait for the operation to complete!
#if CORTEX_MODEL == 7
    __DSB();
#endif
 
    /* Wait for completion */
    intFlashWaitWhileBusy();
 
    /* Exit flash programming mode */
    FLASH->CR &= ~FLASH_CR_PG;
 
    return intFlashCheckErrors();
}

Referenced by intFlashWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

isDualBank()

static bool isDualBank ( void  )

static

Definition at line 160 of file flash_int.cpp.

                             {
#ifdef FLASH_OPTCR_nDBANK
    // cleared bit indicates dual bank
    return (FLASH->OPTCR & FLASH_OPTCR_nDBANK) == 0;
#else
    return 0;
#endif
}

Referenced by intFlashSectorErase().

Here is the caller graph for this function:

Go to the source code of this file.