[单片机框架][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 当64MHz 当 96MHz 当 128MHz

选项字节区擦除和编程

对选项字节区的编程与主存储区不同。选项字节的数目只有 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));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22