[单片机框架][bsp层][N32G4FR][bsp_flash] flash配置和使用

FLASH 规格

Flash 由主存储区、信息区组成，以下分别进行说明： （以下说明中的容量值不含 ECC）
 主存储区最大为 512KB，也称作主闪存存储器，包含 256 个 Page，用于用户程序的存放和运行，以及数据存储。
 信息区为 20KB，包含 10 个 Page，由系统存储区（16KB） 、系统配置区（2KB） 、选项字节区（2KB）

组成：
 系统存储区为 16KB，包含 8 个 Page，也称作 System Memory，用于引导程序（BOOT）的存放和运行。
 系统配置区为 2KB，包含 1 个 Page。
 选项字节区为 2KB，包含 1 个 Page，也称作 OptionByte，有效空间为 18B，BOOT 程序、用户程序均可以读写擦。

读写操作

Flash 写操作仅支持 32 位操作，写操作之前先擦除 Flash，擦除最小块大小是一个 Page 2KB。写操作分为编程和擦除阶段。
读 Flash 时，读的等待周期数可以通过寄存器配置。使用时，需要结合 AHB 接口时钟频率进行计算，等待时间必须不小于 25ns。
比如： 当 HCLK<=32MHz 时， 等待周期数最小为 0；
当 32MHz<HCLK<=64MHz 时，等待周期数最小为 1；
当64MHz<HCLK<=96MHz 时，等待周期数最小为 2；
当 96MHz<HCLK<=128MHz时，等待周期数最小为 3；
当 128MHz<HCLK<=144MHz 时，等待周期数最小为 4。

选项字节区擦除和编程

对选项字节区的编程与主存储区不同。选项字节的数目只有 9 个字节(4 个字节作为写保护，2 个字节作为读保护，1 个字节为配置选项，2 个字节存储用户数据)。对 Flash 解锁后，必须分别写入 KEY1 和 KEY2(2.2.1.3)到 FLASH_OPTKEY 寄存器，再设置 FLASH_CTRL 寄存器的 OPTWE 位为’1’，此时可以对选项字节区进行编程：设置 FLASH_CTRL 寄存器的 OPTPG 位为’1’后写入字到指定的地址。
对选项字节区字编程时， 使用半字中的低字节并自动地计算出高字节(高字节为低字节的反码)， 并开始编程操作，这将保证选项字节和它的反码始终是正确的。
选项字节区擦除过程：
 检查 FLASH_ STS 寄存器的 BUSY 位，以确认没有其他正在进行的闪存操作；
 解锁 FLASH_CTRL 寄存器的 OPTWE 位；
 设置 FLASH_CTRL 寄存器的 OPTER 位为’1’；
 设置 FLASH_CTRL 寄存器的 START 位为’1’；
 等待 BUSY 位变为’0’；
 读出被擦除的选项字节并做验证。
选项字节区编程过程：
 检查 FLASH_ STS 寄存器的 BUSY 位，以确认没有其他正在进行的闪存操作；
 解锁 FLASH_CTRL 寄存器的 OPTWE 位；
 设置 FLASH_CTRL 寄存器的 OPTPG 位为’1’；

#include "n32g4fr.h"
#include "errorno.h"
#include "bsp_flash.h"

#define FLASH_PAGE_SIZE         2048
#define FLASH_OB_DATA_ADDR      0x1FFFF804
#define FLASH_OB_DATA1_ADDR     0x1FFFF806

uint16_t bsp_flash_get_page_size(void)
{
    return FLASH_PAGE_SIZE;
}


static inline int32_t bsp_flash_sts_to_errno(FLASH_STS sts)
{
    int32_t ret = RETVAL(E_OK);

    if (sts == FLASH_TIMEOUT)
    {
        ret = RETVAL(E_TIMEOUT);
    }
    else if (sts == FLASH_BUSY)
    {
        ret = RETVAL(E_BUSY);
    }
    else if(sts == FLASH_ERR_ADD)
    {
        ret = RETVAL(E_INVAL_ADDR);
    }
    else if (sts != FLASH_COMPL)
    {
        ret = RETVAL(E_FAIL);
    }

    return ret;
}

int32_t bsp_flash_erase_page(uint32_t addr)
{
    int32_t ret = RETVAL(E_OK);
    FLASH_STS sts;

    FLASH_Unlock();
    sts = FLASH_EraseOnePage(addr);
    ret = bsp_flash_sts_to_errno(sts);
    FLASH_Lock();

    return ret;
}

int32_t bsp_flash_write_words(uint32_t addr, uint32_t *data, uint32_t len)
{
    FLASH_STS err;
    int32_t ret = RETVAL(E_OK);
    uint32_t write_len;
    uint32_t i;

    if (len % sizeof(uint32_t) != 0)
    {
        return RETVAL(E_INVAL_LEN);
    }
    write_len = len / sizeof(uint32_t);

    FLASH_Unlock();
    for (i = 0; i < write_len; i++)
    {
        err = FLASH_ProgramWord(addr + i * sizeof(uint32_t), data[i]);
        if (err != FLASH_COMPL)
        {
            ret = RETVAL(E_FAIL);
            break;
        }
    }
    FLASH_Lock();

    return ret;
}

uint8_t bsp_flash_read_byte(uint32_t addr)
{
    return *(__IO uint8_t *)addr;
}

void bsp_flash_read_bytes(uint32_t addr, uint8_t *data, uint32_t len)
{
    uint32_t i;

    for (i = 0; i < len; i++)
    {
        *(data + i) = bsp_flash_read_byte(addr + i * sizeof(uint8_t));
    }
}

uint32_t bsp_flash_read_word(uint32_t addr)
{
    return *(__IO uint32_t *)addr;
}

void bsp_flash_read_words(uint32_t addr, uint32_t *data, uint32_t word_len)
{
    uint32_t i;

    for (i = 0; i < word_len; i++)
    {
        *(data + i) = bsp_flash_read_word(addr + i * sizeof(uint32_t));
    }
}

int32_t bsp_flash_carry(uint32_t t_addr, uint32_t s_addr, uint32_t size)
{
    FLASH_STS sts;
    int32_t ret = RETVAL(E_OK);
    uint32_t word_len;
    uint32_t page_len;
    uint32_t i;

    word_len = (size / sizeof(uint32_t));
    page_len = (size % FLASH_PAGE_SIZE) == 0 ?
                (size / FLASH_PAGE_SIZE) : (size / FLASH_PAGE_SIZE) + 1;
    
    for (i = 0; i < page_len; i++)
    {
        bsp_flash_erase_page(t_addr + i * FLASH_PAGE_SIZE);
    }

    FLASH_Unlock();
    
    for (i = 0; i < word_len; i++)
    {
        sts = FLASH_ProgramWord(t_addr + i * sizeof(uint32_t),
                                bsp_flash_read_word(s_addr + i * sizeof(uint32_t)));
        if (sts != FLASH_COMPL)
        {
            break;
        }
    }

    FLASH_Lock();

    ret = bsp_flash_sts_to_errno(sts);
    if (ret == RETVAL(E_OK))
    {
        for (i = 0; i < page_len; i++)
        {
            bsp_flash_erase_page(s_addr + i * FLASH_PAGE_SIZE);
        }
    }
    
    return ret;
}

void bsp_flash_erase_nv(void)
{
    FLASH_Unlock();
    FLASH_EraseOB();
    FLASH_Lock();
}

/**
 * @brief OB Data bit is Half word
 * @param data (Data1 << 8)| Data0
 */
int32_t bsp_flash_write_nv(uint16_t data)
{
    FLASH_STS sts;
    int32_t ret = RETVAL(E_OK);

    bsp_flash_erase_nv();

    FLASH_Unlock();
    //OB Data only Low eight bit effective.  high 8bit  [low 8bit]
    sts = FLASH_ProgramOBData(FLASH_OB_DATA_ADDR, 
                            (((data >> 8) & 0x00FF) << 16) | (data & 0x00FF));

    FLASH_Lock();

    ret = bsp_flash_sts_to_errno(sts);
    return ret;
}

uint16_t bsp_flash_read_nv(void)
{
    return ((bsp_flash_read_byte(FLASH_OB_DATA1_ADDR) << 8) |
            bsp_flash_read_byte(FLASH_OB_DATA_ADDR));
}

#ifndef __BSP_FLASH_H__
#define __BSP_FLASH_H__

#include "typedefs.h"

uint16_t bsp_flash_get_page_size(void);
int32_t  bsp_flash_erase_page(uint32_t addr);

uint8_t  bsp_flash_read_byte(uint32_t addr);
void     bsp_flash_read_bytes(uint32_t addr, uint8_t *data, uint32_t len);
uint32_t bsp_flash_read_word(uint32_t addr);
void     bsp_flash_read_words(uint32_t addr, uint32_t *data, uint32_t len);

int32_t  bsp_flash_write_words(uint32_t addr, uint32_t *data, uint32_t len);
int32_t  bsp_flash_carry(uint32_t t_addr, uint32_t s_addr, uint32_t size);

void     bsp_flash_erase_nv(void);
int32_t  bsp_flash_write_nv(uint16_t data);
uint16_t bsp_flash_read_nv(void);

#endif