임베디드 Flash 프로그래밍 — Erase·Program·Read While Write

1
Sector  Size    Address range
2
0       16KB    0x0800 0000 ~ 0x0800 3FFF
3
1       16KB    0x0800 4000 ~ 0x0800 7FFF
4
2       16KB    0x0800 8000 ~ 0x0800 BFFF
5
3       16KB    0x0800 C000 ~ 0x0800 FFFF
6
4       64KB    0x0801 0000 ~ 0x0801 FFFF
7
5       128KB   0x0802 0000 ~ 0x0803 FFFF
8
6       128KB   0x0804 0000 ~ 0x0805 FFFF
9
7       128KB   0x0806 0000 ~ 0x0807 FFFF
10
                                          (512 KB total)

1
#define FLASH_KEY1  0x45670123u
2
#define FLASH_KEY2  0xCDEF89ABu
3

4
static void flash_unlock(void) {
5
    if (FLASH->CR & FLASH_CR_LOCK) {
6
        FLASH->KEYR = FLASH_KEY1;
7
        FLASH->KEYR = FLASH_KEY2;
8
    }
9
}
10

11
static void flash_lock(void) {
12
    FLASH->CR |= FLASH_CR_LOCK;
13
}

1
int flash_erase_sector(uint8_t sector) {
2
    while (FLASH->SR & FLASH_SR_BSY);
3
    FLASH->SR = FLASH_SR_EOP | FLASH_SR_OPERR | FLASH_SR_WRPERR
4
              | FLASH_SR_PGAERR | FLASH_SR_PGPERR | FLASH_SR_PGSERR;
5

6
    flash_unlock();
7
    FLASH->CR &= ~FLASH_CR_PSIZE;
8
    FLASH->CR |= (2u << 8);             // PSIZE = word (3.3V)
9
    FLASH->CR &= ~(0x1F << 3);
10
    FLASH->CR |= FLASH_CR_SER | (sector << 3);
11
    FLASH->CR |= FLASH_CR_STRT;
12

13
    while (FLASH->SR & FLASH_SR_BSY);
14

15
    FLASH->CR &= ~FLASH_CR_SER;
16
    flash_lock();
17

18
    return (FLASH->SR & 0xF0) ? -1 : 0;
19
}

1
int flash_write_word(uint32_t addr, uint32_t data) {
2
    while (FLASH->SR & FLASH_SR_BSY);
3

4
    flash_unlock();
5
    FLASH->CR &= ~FLASH_CR_PSIZE;
6
    FLASH->CR |= (2u << 8);             // word
7
    FLASH->CR |= FLASH_CR_PG;
8

9
    *(volatile uint32_t *)addr = data;
10

11
    while (FLASH->SR & FLASH_SR_BSY);
12

13
    FLASH->CR &= ~FLASH_CR_PG;
14
    flash_lock();
15

16
    return (*(volatile uint32_t *)addr == data) ? 0 : -1;
17
}

1
Sector 1 (16 KB):
2
+--------+--------+--------+--------+--------+
3
| key=A  | key=B  | key=A  | key=C  | empty  |
4
| val=10 | val=20 | val=15 | val=30 | 0xFFFF |
5
+--------+--------+--------+--------+--------+
6

7
read(A) → 마지막에서 역방향 search → val=15

1
typedef struct {
2
    uint16_t key;
3
    uint16_t value;
4
    uint32_t magic;   // 0xDEAD_BEEF when written
5
} ee_entry_t;
6

7
#define EE_SECTOR    1
8
#define EE_BASE      0x08004000UL
9
#define EE_END       0x08008000UL
10

11
uint16_t ee_read(uint16_t key) {
12
    ee_entry_t *p = (ee_entry_t *)(EE_END - sizeof(ee_entry_t));
13
    while ((uint32_t)p >= EE_BASE) {
14
        if (p->magic == 0xDEADBEEFu && p->key == key) {
15
            return p->value;
16
        }
17
        p--;
18
    }
19
    return 0xFFFF;   // not found
20
}
21

22
int ee_write(uint16_t key, uint16_t val) {
23
    ee_entry_t *p = (ee_entry_t *)EE_BASE;
24
    while ((uint32_t)p < EE_END) {
25
        if (p->magic == 0xFFFFFFFFu) {
26
            // empty slot
27
            ee_entry_t entry = {.key=key, .value=val, .magic=0xDEADBEEFu};
28
            flash_write_word((uint32_t)&p->key,
29
                             ((uint32_t)val << 16) | key);
30
            flash_write_word((uint32_t)&p->magic, 0xDEADBEEFu);
31
            return 0;
32
        }
33
        p++;
34
    }
35
    return -1;   // full — need compact
36
}

1
// 일관성 확인
2
flash_erase_sector(EE_SECTOR);
3

4
// erase 후 모두 0xFF
5
for (uint32_t a = EE_BASE; a < EE_END; a += 4) {
6
    if (*(volatile uint32_t *)a != 0xFFFFFFFFu) {
7
        printf("Erase failed at %08lx\n", a);
8
        break;
9
    }
10
}
11

12
// write + read back
13
flash_write_word(EE_BASE, 0xDEADBEEFu);
14
if (*(volatile uint32_t *)EE_BASE != 0xDEADBEEFu) {
15
    printf("Write failed\n");
16
}

1
Sector 1 (16 KB) erase: 412 ms
2
Word write × 4096: 76 ms total (18 µs each)

1
MEMORY {
2
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 16K   /* boot */
3
    EEPROM (rw) : ORIGIN = 0x08004000, LENGTH = 32K   /* reserved */
4
    APP (rx)    : ORIGIN = 0x0800C000, LENGTH = 464K
5
}