换种方式玩转SPI Flash，还支持文件系统

#define SFUD_USING_SFDP



enum {

    SFUD_M25P_DEVICE_INDEX = 0,

};



#define SFUD_FLASH_DEVICE_TABLE                                                \

{                                                                              \

    [SFUD_M25P_DEVICE_INDEX] = {.name = "M25P80", .spi.name = "SPI2"},       \

}

/**

 * add your spi flash user data struct typedef

 */

typedef struct {

    SPI_TypeDef *spix;

    GPIO_TypeDef *cs_gpiox;

    uint16_t cs_gpio_pin;

} spi_user_data, *spi_user_data_t;



static spi_user_data spi2 = { .spix = SPI2, .cs_gpiox = GPIOB, .cs_gpio_pin = GPIO_Pin_12 };



static char log_buf[256];



void sfud_log_debug(const char *file, const long line, const char *format, ...);



/**

 * SPI write data then read data

 */

static sfud_err spi_write_read(const sfud_spi *spi, const uint8_t *write_buf, size_t write_size, uint8_t *read_buf,

        size_t read_size) {

    sfud_err result = SFUD_SUCCESS;

    uint8_t send_data, read_data;



    spi_user_data_t spi_dev = (spi_user_data_t) spi->user_data;



    if (write_size) {

        SFUD_ASSERT(write_buf);

    }

    if (read_size) {

        SFUD_ASSERT(read_buf);

    }



//    GPIO_ResetBits(spi_dev->cs_gpiox, spi_dev->cs_gpio_pin);/* 软件NSS */

    SPI_CSInternalSelected(SPI2, ENABLE);/* 硬件NSS */

    /* 开始读写数据 */

    for (size_t i = 0, retry_times; i < write_size + read_size; i++) {

        /* 先写缓冲区中的数据到 SPI 总线，数据写完后，再写 dummy(0xFF) 到 SPI 总线 */

        if (i < write_size) {

            send_data = *write_buf++;

        } else {

            send_data = SFUD_DUMMY_DATA;

        }

        /* 发送数据 */

        retry_times = 1000;

        while (SPI_GetFlagStatus(spi_dev->spix, SPI_FLAG_TXEPT) == RESET) {

            SFUD_RETRY_PROCESS(NULL, retry_times, result);

        }

        if (result != SFUD_SUCCESS) {

            goto exit;

        }

        SPI_SendData(spi_dev->spix, send_data);

        

        /* 接收数据 */

        retry_times = 1000;

        while (SPI_GetFlagStatus(spi_dev->spix, SPI_FLAG_RXAVL) == RESET) {

            SFUD_RETRY_PROCESS(NULL, retry_times, result);

        }

        if (result != SFUD_SUCCESS) {

            goto exit;

        }

        read_data = SPI_ReceiveData(spi_dev->spix);

        /* 写缓冲区中的数据发完后，再读取 SPI 总线中的数据到读缓冲区 */

        if (i >= write_size) {

            *read_buf++ = read_data;

        }

    }



exit:

//    GPIO_SetBits(spi_dev->cs_gpiox, spi_dev->cs_gpio_pin);

    SPI_CSInternalSelected(SPI2, DISABLE);

    

    return result;

}



/**

 * add your spi flash user function

 */

/* about 100 microsecond delay */

static void retry_delay_100us(void) {

    uint32_t delay = 80; /* 120 [url=home.php?mod=space&uid=442618]@72mhz[/url] */

    while(delay--);

}



static void spi_lock(const sfud_spi *spi) {

    __disable_irq();

}



static void spi_unlock(const sfud_spi *spi) {

    __enable_irq();

}





sfud_err sfud_spi_port_init(sfud_flash *flash) {

    sfud_err result = SFUD_SUCCESS;



    switch (flash->index) {

        case SFUD_M25P_DEVICE_INDEX: {

            SPI_FLASH_Init();

            /* 同步 Flash 移植所需的接口及数据 */

            flash->spi.wr = spi_write_read;

            flash->spi.lock = spi_lock;

            flash->spi.unlock = spi_unlock;

            flash->spi.user_data = &spi2;

            /* about 100 microsecond delay */

            flash->retry.delay = retry_delay_100us;

            /* adout 60 seconds timeout */

            flash->retry.times = 60 * 10000;



            break;

        }

    }



    return result;

}

static int lfs_flash_read(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size);

static int lfs_flash_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size);

static int lfs_flash_erase(const struct lfs_config *c, lfs_block_t block);

static int lfs_flash_sync(const struct lfs_config *c);

static int lfs_flash_read(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size)

{

    uint32_t addr;

    addr = ((uint32_t)block << (uint32_t)12);

    addr += off;



    const sfud_flash *flash = sfud_get_device_table() + 0;



#ifdef SFUD_DEBUG_MODE

    char message[64];

    if (Flash_Debug_Flag)

    {

        memset(message, 0x00, sizeof(message));



        sprintf(message, "Flash Read Block is %d, Offset is %d, Size is %d\n\r", block, off, size);

        debug_log(message, strlen(message));

    }



#endif



    sfud_read(flash, addr, size, (uint8_t *)buffer);

    return LFS_ERR_OK;

}



static int

lfs_flash_prog(const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)

{

    uint32_t addr;

    addr = ((uint32_t)block << (uint32_t)12);

    addr += off;



    const sfud_flash *flash = sfud_get_device_table() + 0;



#ifdef SFUD_DEBUG_MODE

    char message[64];

    if (Flash_Debug_Flag)

    {

        memset(message, 0x00, sizeof(message));



        sprintf(message, "Flash Prog Block is %d, Offset is %d, Size if %d\n\r", block, off, size);

        debug_log(message, strlen(message));

    }



#endif



    sfud_write(flash, addr, size, (uint8_t *)buffer);

    return LFS_ERR_OK;

}



static int lfs_flash_erase(const struct lfs_config *c, lfs_block_t block)

{

    const sfud_flash *flash = sfud_get_device_table() + 0;



#ifdef SFUD_DEBUG_MODE

    char message[64];



    if (Flash_Debug_Flag)

    {

        memset(message, 0x00, sizeof(message));



        sprintf(message, "Erase Block is %d\n\r", block);

        debug_log(message, strlen(message));

    }



#endif



    sfud_erase(flash, block << 12, BLOCK_SIZE);

    return LFS_ERR_OK;

}



static int lfs_flash_sync(const struct lfs_config *c)

{

    return LFS_ERR_OK;

}