SD Card + FatFs 구현 — SPI/SDIO 모드·CSD/CID·Wear

1
CMD17 READ_SINGLE_BLOCK
2
CMD18 READ_MULTIPLE_BLOCK
3
CMD24 WRITE_BLOCK
4
CMD25 WRITE_MULTIPLE_BLOCK

1
DSTATUS disk_initialize(BYTE pdrv);
2
DSTATUS disk_status(BYTE pdrv);
3
DRESULT disk_read(BYTE pdrv, BYTE *buff, LBA_t sector, UINT count);
4
DRESULT disk_write(BYTE pdrv, const BYTE *buff, LBA_t sector, UINT count);
5
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff);

1
#define CS_LOW()  GPIOA->BSRR = (1u << (4+16))
2
#define CS_HIGH() GPIOA->BSRR = (1u << 4)
3

4
uint8_t spi_xfer8(uint8_t tx);   // 4-08 참고
5

6
static uint8_t sd_cmd(uint8_t cmd, uint32_t arg, uint8_t crc) {
7
    spi_xfer8(0xFF);
8
    spi_xfer8(0x40 | cmd);
9
    spi_xfer8(arg >> 24);
10
    spi_xfer8(arg >> 16);
11
    spi_xfer8(arg >> 8);
12
    spi_xfer8(arg);
13
    spi_xfer8(crc);
14

15
    // R1 response (max 8 tries)
16
    uint8_t r;
17
    for (int i = 0; i < 10; i++) {
18
        r = spi_xfer8(0xFF);
19
        if ((r & 0x80) == 0) return r;
20
    }
21
    return 0xFF;
22
}
23

24
int sd_init(void) {
25
    CS_HIGH();
26
    spi_set_speed_low();           // 100-400 kHz
27
    for (int i = 0; i < 10; i++) spi_xfer8(0xFF);  // 80 clock
28

29
    CS_LOW();
30
    if (sd_cmd(0, 0, 0x95) != 0x01) { CS_HIGH(); return -1; }   // CMD0
31

32
    uint8_t r = sd_cmd(8, 0x1AA, 0x87);
33
    int v2 = (r == 0x01);
34
    if (v2) {
35
        for (int i = 0; i < 4; i++) spi_xfer8(0xFF);   // discard 32-bit echo
36
    }
37

38
    // ACMD41
39
    for (int t = 0; t < 1000; t++) {
40
        sd_cmd(55, 0, 0xFF);
41
        if (sd_cmd(41, v2 ? 0x40000000 : 0, 0xFF) == 0x00) break;
42
        delay_ms(10);
43
    }
44

45
    // CMD58 → CCS bit
46
    int sdhc = 0;
47
    if (sd_cmd(58, 0, 0xFF) == 0x00) {
48
        uint32_t ocr = (spi_xfer8(0xFF) << 24) | (spi_xfer8(0xFF) << 16)
49
                     | (spi_xfer8(0xFF) << 8)  |  spi_xfer8(0xFF);
50
        sdhc = (ocr & (1u << 30)) ? 1 : 0;
51
    }
52

53
    if (!sdhc) sd_cmd(16, 512, 0xFF);   // block size
54

55
    CS_HIGH();
56
    spi_set_speed_high();   // 10-25 MHz
57
    return sdhc ? 1 : 0;
58
}

1
int sd_read_block(uint32_t lba, uint8_t *buf) {
2
    CS_LOW();
3
    if (sd_cmd(17, lba, 0xFF) != 0x00) { CS_HIGH(); return -1; }
4

5
    // wait data token 0xFE
6
    uint8_t r;
7
    for (int t = 0; t < 100000; t++) {
8
        r = spi_xfer8(0xFF);
9
        if (r == 0xFE) break;
10
    }
11
    if (r != 0xFE) { CS_HIGH(); return -2; }
12

13
    for (int i = 0; i < 512; i++) buf[i] = spi_xfer8(0xFF);
14
    spi_xfer8(0xFF); spi_xfer8(0xFF);   // CRC (ignored)
15
    CS_HIGH();
16
    return 0;
17
}
18

19
int sd_write_block(uint32_t lba, const uint8_t *buf) {
20
    CS_LOW();
21
    if (sd_cmd(24, lba, 0xFF) != 0x00) { CS_HIGH(); return -1; }
22

23
    spi_xfer8(0xFF);
24
    spi_xfer8(0xFE);             // data token
25
    for (int i = 0; i < 512; i++) spi_xfer8(buf[i]);
26
    spi_xfer8(0xFF); spi_xfer8(0xFF);   // CRC
27

28
    uint8_t r = spi_xfer8(0xFF);
29
    if ((r & 0x1F) != 0x05) { CS_HIGH(); return -2; }   // not accepted
30

31
    // wait busy
32
    while (spi_xfer8(0xFF) != 0xFF);
33
    CS_HIGH();
34
    return 0;
35
}

1
#include "diskio.h"
2

3
DSTATUS disk_initialize(BYTE pdrv) {
4
    return (sd_init() < 0) ? STA_NOINIT : 0;
5
}
6

7
DSTATUS disk_status(BYTE pdrv) { return 0; }
8

9
DRESULT disk_read(BYTE pdrv, BYTE *buf, LBA_t lba, UINT n) {
10
    for (UINT i = 0; i < n; i++) {
11
        if (sd_read_block(lba + i, buf + i * 512) < 0) return RES_ERROR;
12
    }
13
    return RES_OK;
14
}
15

16
DRESULT disk_write(BYTE pdrv, const BYTE *buf, LBA_t lba, UINT n) {
17
    for (UINT i = 0; i < n; i++) {
18
        if (sd_write_block(lba + i, buf + i * 512) < 0) return RES_ERROR;
19
    }
20
    return RES_OK;
21
}
22

23
DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buf) {
24
    switch (cmd) {
25
        case CTRL_SYNC: return RES_OK;
26
        case GET_SECTOR_SIZE: *(WORD *)buf = 512; return RES_OK;
27
        // 더 자세한 IOCTL은 FatFs docs 참고
28
    }
29
    return RES_PARERR;
30
}
31

32
DWORD get_fattime(void) {
33
    // RTC 연결되어 있으면 그 시간, 없으면 fixed
34
    return ((2026 - 1980) << 25) | (5 << 21) | (14 << 16);
35
}

1
#include "ff.h"
2

3
void demo(void) {
4
    FATFS fs;
5
    FIL fp;
6
    UINT bw, br;
7
    char line[64];
8

9
    f_mount(&fs, "", 0);
10

11
    // Write
12
    if (f_open(&fp, "log.txt", FA_CREATE_ALWAYS | FA_WRITE) == FR_OK) {
13
        f_write(&fp, "Hello, SD!\n", 11, &bw);
14
        f_close(&fp);
15
    }
16

17
    // Read
18
    if (f_open(&fp, "log.txt", FA_READ) == FR_OK) {
19
        f_read(&fp, line, sizeof(line) - 1, &br);
20
        line[br] = 0;
21
        printf("Read: %s", line);
22
        f_close(&fp);
23
    }
24
}

1
#define FF_USE_LFN  1     // 0=off, 1=static, 2=stack, 3=heap
2
#define FF_MAX_LFN  255
3
#define FF_LFN_UNICODE 0  // 0=ANSI/OEM, 1=UTF-16, 2=UTF-8

1
uint32_t t = millis();
2
char buf[512];
3
for (int i = 0; i < 1000; i++) {
4
    UINT bw;
5
    f_write(&fp, buf, 512, &bw);
6
}
7
f_sync(&fp);
8
printf("Write 500 KB: %lu ms\n", millis() - t);