563 lines
14 KiB
C
563 lines
14 KiB
C
#include "sys_config.h"
|
||
#include "integer.h"
|
||
#include "diskio.h"
|
||
#include "ff.h"
|
||
#include <stdio.h>
|
||
#include "osal/sleep.h"
|
||
#include "typesdef.h"
|
||
#include "osal/task.h"
|
||
#include "osal/semaphore.h"
|
||
#include "osal/mutex.h"
|
||
#include "list.h"
|
||
#include "dev.h"
|
||
#include "sdhost.h"
|
||
#include "devid.h"
|
||
|
||
#include "osal/string.h"
|
||
#include "osal/work.h"
|
||
|
||
// #include "osal.h"
|
||
|
||
#define FAT_INFO_SHOW(...) //printf(__VA_ARGS__)
|
||
|
||
// #define FAT_TIME
|
||
|
||
#if FS_EN
|
||
static uint8_t fat_ready = 0;
|
||
|
||
uint8_t get_fat_isready()
|
||
{
|
||
return fat_ready;
|
||
}
|
||
|
||
void set_fat_ready(uint8_t ready)
|
||
{
|
||
fat_ready = ready;
|
||
}
|
||
|
||
static DSTATUS fatfs_status(void *status);
|
||
static DSTATUS fatfs_init(void *init_dev);
|
||
static DRESULT fatfs_read(void *dev, BYTE *buf, DWORD sector, UINT count);
|
||
static DRESULT fatfs_write(void *dev, BYTE *buf, DWORD sector, UINT count);
|
||
static DRESULT fatfs_ioctl(void *init_dev, BYTE cmd, void *buf);
|
||
uint32 get_sdhost_status(struct sdh_device *host);
|
||
uint32 sd_tran_stop(struct sdh_device *host);
|
||
static const struct fatfs_diskio sdcdisk_driver = {
|
||
.status = fatfs_status,
|
||
.init = fatfs_init,
|
||
.read = fatfs_read,
|
||
.write = fatfs_write,
|
||
.ioctl = fatfs_ioctl};
|
||
|
||
static FATFS fatfs[1];
|
||
|
||
DWORD get_fatbase(int num)
|
||
{
|
||
return fatfs[num].fatbase;
|
||
}
|
||
|
||
DWORD get_fatfree(int num)
|
||
{
|
||
DWORD fre_clust, fre_sect, tot_sect;
|
||
FATFS *fs = &fatfs[num];
|
||
fre_clust = fs->free_clst;
|
||
tot_sect = (fs->n_fatent - 2) * fs->csize;
|
||
fre_sect = fre_clust * fs->csize;
|
||
printf("%s %ldKB\n", __FUNCTION__, fre_sect >> 1);
|
||
return fre_sect >> 1;
|
||
}
|
||
|
||
static DSTATUS fatfs_status(void *status)
|
||
{
|
||
// FAT_INFO_SHOW ("fatfs_status_test\r\n");
|
||
uint32 err = get_sdhost_status(status);
|
||
return err;
|
||
}
|
||
|
||
static DSTATUS fatfs_init(void *init_dev){
|
||
printf ("fatfs_init_test\r\n");
|
||
uint32 err = get_sdhost_status(init_dev);
|
||
if(err)
|
||
{
|
||
err = sdhost_init(48 * 1000 * 1000, 0);
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
#if USE_FAT_CACHE
|
||
// 内存分配函数
|
||
static void *fat_malloc(int size)
|
||
{
|
||
#ifdef PSRAM_HEAP
|
||
return os_malloc_psram(size);
|
||
#else
|
||
return os_malloc(size);
|
||
#endif
|
||
}
|
||
|
||
// 内存释放函数
|
||
static void fat_free(void *p)
|
||
{
|
||
#ifdef PSRAM_HEAP
|
||
os_free_psram(p);
|
||
#else
|
||
os_free(p);
|
||
#endif
|
||
}
|
||
struct fat_data_t
|
||
{
|
||
// uint8 data[FAT_CACHE_SIZE * 512]; // 32KB 缓存
|
||
BYTE *data; // 32KB 缓存
|
||
DWORD start_sector; // 缓存起始扇区
|
||
DWORD fat_start; // FAT起始扇区
|
||
DWORD fat_end;
|
||
DWORD offset;
|
||
DWORD max_offset;
|
||
};
|
||
|
||
struct fat_cache_t
|
||
{
|
||
BYTE fat_info_ready; //
|
||
BYTE fat_init;
|
||
BYTE fs_type;
|
||
BYTE fs_fats;
|
||
DWORD fs_size;
|
||
DWORD fat_tick;
|
||
#ifdef FAT_TIME
|
||
os_timer_t fat_timer;
|
||
#else
|
||
struct os_work fat_wk;
|
||
#endif
|
||
struct os_mutex lock;
|
||
struct fat_data_t fat1;
|
||
};
|
||
|
||
|
||
|
||
struct fat_cache_t fat_cache = {
|
||
// lock和time初始化标志位，1是未初始化，0是已经初始化
|
||
.fat_init = 1,
|
||
.fat_info_ready = 1,
|
||
};
|
||
|
||
signed char update_fat_info(BYTE fmt, BYTE n_fats, DWORD sz_fat,DWORD fatbase, DWORD b_vol)
|
||
{
|
||
if (fat_cache.fat_init != RET_OK){
|
||
return RET_ERR;
|
||
}
|
||
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
|
||
fat_cache.fs_type = fmt;
|
||
fat_cache.fs_fats = n_fats;
|
||
fat_cache.fs_size = sz_fat;
|
||
|
||
fat_cache.fat1.fat_start = fatbase;
|
||
fat_cache.fat1.fat_end = fat_cache.fat1.fat_start + fat_cache.fs_size - 1;
|
||
|
||
fat_cache.fat_info_ready = RET_OK;
|
||
|
||
// 计算逻辑地址（扇区号）
|
||
//UINT fat1_logical = fatbase - b_vol; // FAT1 logical start
|
||
//UINT fat2_logical = fat1_logical + sz_fat; // FAT2 logical start
|
||
|
||
// 计算物理地址（加上分区偏移）
|
||
//UINT partition_start = b_vol; // 分区起始扇区
|
||
//UINT fat1_physical = partition_start + fat1_logical;
|
||
//UINT fat2_physical = partition_start + fat2_logical;
|
||
|
||
// if (fat_cache.fs_type == FS_EXFAT) // FS_EXFAT文件系统不需要优化
|
||
// {
|
||
// fat_cache.fat_info_ready = 0;
|
||
// }
|
||
|
||
if (fmt == FS_FAT12)
|
||
FAT_INFO_SHOW("Filesystem Type: FS_FAT12 \r\n");
|
||
else if (fmt == FS_FAT16)
|
||
FAT_INFO_SHOW("Filesystem Type: FS_FAT16 \r\n");
|
||
else if (fmt == FS_FAT32)
|
||
FAT_INFO_SHOW("Filesystem Type: FS_FAT32 \r\n");
|
||
else if (fmt == FS_EXFAT)
|
||
FAT_INFO_SHOW("Filesystem Type: FS_EXFAT \r\n");
|
||
|
||
FAT_INFO_SHOW("Filesystem fat_num %u \r\n", n_fats);
|
||
FAT_INFO_SHOW("Filesystem fat_size %u \r\n", sz_fat);
|
||
|
||
FAT_INFO_SHOW("Physical Address ===> fat1_start %u , fat1_end %u \r\n", fat_cache.fat1.fat_start, fat_cache.fat1.fat_end);
|
||
FAT_INFO_SHOW("Logical Address ====> fat1_start %u , fat1_end %u \r\n", fat1_logical, fat1_logical + sz_fat - 1);
|
||
|
||
if (n_fats > 1) {
|
||
FAT_INFO_SHOW("Physical Address ===> fat2_start %u , fat2_end %u \r\n", fat2_physical, fat2_physical + sz_fat - 1);
|
||
FAT_INFO_SHOW("Logical Address ====> fat2_start %u , fat2_end %u \r\n", fat2_logical, fat2_logical + sz_fat - 1);
|
||
}
|
||
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
|
||
return RET_OK;
|
||
}
|
||
|
||
void update_io_timestamp()
|
||
{
|
||
if (fat_cache.fat_init != RET_OK || fat_cache.fat_info_ready != RET_OK){
|
||
return;
|
||
}
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
fat_cache.fat_tick = os_jiffies();
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
}
|
||
|
||
// fat回写SD
|
||
static void fat_cache_sync(struct sdh_device *host)
|
||
{
|
||
struct sdh_device *sdh = NULL;
|
||
sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
if (fat_cache.fat_init != RET_OK || fat_cache.fat_info_ready != RET_OK){
|
||
return;
|
||
}
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
|
||
FAT_INFO_SHOW("############# CTRL_SYNC max_offset %d\r\n", fat_cache.fat1.max_offset);
|
||
if (fat_cache.fat1.max_offset > 0)
|
||
{
|
||
sd_multiple_write((struct sdh_device *)host, fat_cache.fat1.start_sector, fat_cache.fat1.max_offset * 512, fat_cache.fat1.data);
|
||
if (fat_cache.fs_fats > 1)
|
||
{
|
||
sd_multiple_write((struct sdh_device *)host, (fat_cache.fat1.start_sector + fat_cache.fs_size), fat_cache.fat1.max_offset * 512, fat_cache.fat1.data);
|
||
}
|
||
fat_cache.fat1.max_offset = 0;
|
||
}
|
||
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
}
|
||
|
||
#ifdef FAT_TIME
|
||
static void fat_loop(void *arg)
|
||
#else
|
||
static int32 fat_loop(struct os_work *work)
|
||
#endif
|
||
{
|
||
if (fat_cache.fat_init != RET_OK || fat_cache.fat_info_ready != RET_OK){
|
||
goto fat_loop_end;
|
||
}
|
||
|
||
uint8 ret = 0;
|
||
struct sdh_device *sdh = NULL;
|
||
sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
|
||
ret = os_mutex_lock(&sdh->lock, 0);
|
||
if (ret != RET_OK)
|
||
{
|
||
fat_cache.fat_tick = os_jiffies();
|
||
goto fat_loop_end; // 获取锁失败
|
||
}
|
||
os_mutex_unlock(&sdh->lock);
|
||
ret = os_mutex_lock(&fat_cache.lock, 0);
|
||
if (ret != RET_OK)
|
||
{
|
||
goto fat_loop_end; // 获取锁失败
|
||
}
|
||
|
||
// 检测到200ms没有操作SD卡，并SD卡在线，fat信息回写SD
|
||
if (os_jiffies() - fat_cache.fat_tick > 200 && SD_OFF != sdh->sd_opt)
|
||
{
|
||
fat_cache.fat_tick = os_jiffies();
|
||
if (fat_cache.fat1.max_offset > 0)
|
||
{
|
||
FAT_INFO_SHOW(" fat_loop write back max_offset %d\r\n", fat_cache.fat1.max_offset);
|
||
sd_multiple_write(sdh, fat_cache.fat1.start_sector, fat_cache.fat1.max_offset * 512, fat_cache.fat1.data);
|
||
if (fat_cache.fs_fats > 1) // 写入FAT2
|
||
{
|
||
sd_multiple_write(sdh, (fat_cache.fat1.start_sector + fat_cache.fs_size), fat_cache.fat1.max_offset * 512, fat_cache.fat1.data);
|
||
}
|
||
fat_cache.fat1.max_offset = 0;
|
||
}
|
||
}
|
||
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
fat_loop_end:
|
||
#ifdef FAT_TIME
|
||
return;
|
||
#else
|
||
os_run_work_delay(work, 50);
|
||
return 0;
|
||
#endif
|
||
|
||
}
|
||
|
||
static void init_fat_cache(FATFS *fs)
|
||
{
|
||
if (update_fat_info(fs->fs_type, fs->n_fats, fs->fsize,fs->fatbase, fs->volbase) != RET_OK){
|
||
return;
|
||
}
|
||
FAT_INFO_SHOW("init_fat_cache \r\n");
|
||
struct sdh_device *sdh = NULL;
|
||
sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
// 初始化后第一次读fat1
|
||
fat_cache.fat1.start_sector = fs->fatbase;
|
||
sd_multiple_read(sdh, fat_cache.fat1.start_sector, FAT_CACHE_SIZE * 512, fat_cache.fat1.data);
|
||
}
|
||
|
||
static void del_fat_cache(void)
|
||
{
|
||
if (fat_cache.fat_init != RET_OK){
|
||
return;
|
||
}
|
||
|
||
fat_cache.fat_init = 1;
|
||
fat_cache.fat_info_ready = 1;
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
FAT_INFO_SHOW("########### del_fat_cache \r\n");
|
||
|
||
#ifdef FAT_TIME
|
||
os_timer_stop(&fat_cache.fat_timer);
|
||
os_timer_del(&fat_cache.fat_timer);// 先卸载定时器
|
||
#else
|
||
os_work_cancle(&fat_cache.fat_wk,1);
|
||
#endif
|
||
|
||
// 释放fat缓存
|
||
if (fat_cache.fat1.data)
|
||
{
|
||
FAT_INFO_SHOW("%s %d fat free \r\n", __func__, __LINE__);
|
||
fat_free(fat_cache.fat1.data);
|
||
fat_cache.fat1.data = NULL;
|
||
}
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
os_mutex_del(&fat_cache.lock);
|
||
}
|
||
|
||
static DRESULT read_from_fat_cache(void *dev, struct fat_data_t *cache, BYTE *buf, DWORD sector, UINT count)
|
||
{
|
||
int ret = 0;
|
||
if (fat_cache.fat_init != RET_OK || fat_cache.fat_info_ready != RET_OK){
|
||
return sd_multiple_read((struct sdh_device *)dev, sector, count * 512, buf);
|
||
}
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
|
||
if (sector >= cache->start_sector && sector + count <= cache->start_sector + FAT_CACHE_SIZE)
|
||
{
|
||
// 从缓存读取
|
||
cache->offset = (sector - cache->start_sector);
|
||
memcpy(buf, &cache->data[cache->offset * 512], count * 512);
|
||
}
|
||
// 未命中缓存，把旧缓存写入SD，重新预读 16KB 到缓存
|
||
else
|
||
{
|
||
// 把旧缓存写入fat
|
||
if (cache->max_offset > 0)
|
||
{
|
||
FAT_INFO_SHOW("read_from_fat_cache write back max_offset %d sector %d\r\n", cache->max_offset, sector);
|
||
sd_multiple_write((struct sdh_device *)dev, cache->start_sector, cache->max_offset * 512, cache->data);
|
||
if (fat_cache.fs_fats > 1)
|
||
{
|
||
sd_multiple_write((struct sdh_device *)dev, (cache->start_sector + fat_cache.fs_size), cache->max_offset * 512, cache->data);
|
||
}
|
||
cache->max_offset = 0;
|
||
// memset(cache->data, 0, FAT_CACHE_SIZE * 512);
|
||
}
|
||
// 重新预读数据到缓存
|
||
ret = sd_multiple_read((struct sdh_device *)dev, sector, FAT_CACHE_SIZE * 512, cache->data);
|
||
cache->start_sector = sector;
|
||
memcpy(buf, &cache->data[0], count * 512);
|
||
}
|
||
// __end:
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
return ret;
|
||
}
|
||
|
||
static DRESULT write_to_fat_cache(void *dev, struct fat_data_t *cache, BYTE *buf, DWORD sector, UINT count)
|
||
{
|
||
int ret = 0;
|
||
|
||
if (fat_cache.fat_init != RET_OK || fat_cache.fat_info_ready != RET_OK){
|
||
return sd_multiple_write((struct sdh_device *)dev, sector, count * 512, buf);
|
||
}
|
||
os_mutex_lock(&fat_cache.lock, osWaitForever);
|
||
|
||
// 检查是否命中缓存
|
||
if (sector >= cache->start_sector && sector + count <= cache->start_sector + FAT_CACHE_SIZE)
|
||
{
|
||
cache->offset = (sector - cache->start_sector);
|
||
memcpy(&cache->data[cache->offset * 512], buf, count * 512);
|
||
if (cache->max_offset < (cache->offset + 1))
|
||
{
|
||
cache->max_offset = cache->offset + 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 把旧缓存写入fat
|
||
if (cache->max_offset > 0)
|
||
{
|
||
FAT_INFO_SHOW("write_to_fat_cache write back max_offset %d sector %d\r\n", cache->max_offset, sector);
|
||
sd_multiple_write((struct sdh_device *)dev, cache->start_sector, cache->max_offset * 512, cache->data);
|
||
if (fat_cache.fs_fats > 1)
|
||
{
|
||
sd_multiple_write((struct sdh_device *)dev, (cache->start_sector + fat_cache.fs_size), cache->max_offset * 512, cache->data);
|
||
}
|
||
cache->max_offset = 0;
|
||
// memset(cache->data, 0, FAT_CACHE_SIZE * 512);
|
||
}
|
||
// 重新预读数据到缓存
|
||
ret = sd_multiple_read((struct sdh_device *)dev, sector, FAT_CACHE_SIZE * 512, cache->data);
|
||
cache->start_sector = sector;
|
||
|
||
cache->offset = 0;
|
||
memcpy(&cache->data[cache->offset * 512], buf, count * 512);
|
||
|
||
if (cache->max_offset < (cache->offset + 1))
|
||
{
|
||
cache->max_offset = cache->offset + 1;
|
||
}
|
||
}
|
||
// __end:
|
||
os_mutex_unlock(&fat_cache.lock);
|
||
return ret;
|
||
}
|
||
|
||
#endif
|
||
|
||
DRESULT fatfs_read(void *dev, BYTE *buf, DWORD sector, UINT count)
|
||
{
|
||
#if USE_FAT_CACHE
|
||
update_io_timestamp();
|
||
if (sector >= fat_cache.fat1.fat_start && sector <= fat_cache.fat1.fat_end)
|
||
{
|
||
return read_from_fat_cache((struct sdh_device *)dev, &fat_cache.fat1, buf, sector, count);
|
||
}
|
||
#endif
|
||
return sd_multiple_read((struct sdh_device *)dev, sector, count * 512, buf);
|
||
}
|
||
|
||
static DRESULT fatfs_write(void *dev, BYTE *buf, DWORD sector, UINT count)
|
||
{
|
||
#if USE_FAT_CACHE
|
||
update_io_timestamp();
|
||
if (sector >= fat_cache.fat1.fat_start && sector <= fat_cache.fat1.fat_end)
|
||
{
|
||
return write_to_fat_cache((struct sdh_device *)dev, &fat_cache.fat1, buf, sector, count);
|
||
}
|
||
#endif
|
||
return sd_multiple_write((struct sdh_device *)dev, sector, count * 512, buf);
|
||
}
|
||
|
||
extern unsigned int sd_dwCap;
|
||
extern uint32 fatfs_sd_tran_stop(struct sdh_device *host);
|
||
static DRESULT fatfs_ioctl(void *init_dev, BYTE cmd, void *buf)
|
||
{
|
||
uint8 ret = RES_OK;
|
||
switch (cmd)
|
||
{
|
||
case CTRL_SYNC:
|
||
fatfs_sd_tran_stop(init_dev);
|
||
|
||
#if USE_FAT_CACHE
|
||
fat_cache_sync(init_dev);
|
||
#endif
|
||
break;
|
||
case GET_SECTOR_COUNT:
|
||
*(DWORD *)buf = sd_dwCap * 2;
|
||
ret = RES_OK;
|
||
break;
|
||
|
||
case GET_SECTOR_SIZE:
|
||
*(WORD *)buf = 512;
|
||
ret = RES_OK;
|
||
|
||
break;
|
||
case GET_BLOCK_SIZE:
|
||
*(DWORD *)buf = 4;
|
||
// printf("*0B:%d\n",*B);
|
||
ret = RES_OK;
|
||
break;
|
||
|
||
default:
|
||
ret = RES_ERROR; // not finish
|
||
printf("rtos_sd_ioctl err\n");
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
bool fatfs_register()
|
||
{
|
||
|
||
int ret = 1;
|
||
struct sdh_device *fatfs_sdh;
|
||
// printf(">>>>>>>>>> enter %s test\r\n", __func__);
|
||
fatfs_sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
|
||
#if USE_FAT_CACHE
|
||
if (fat_cache.fat_init)
|
||
{
|
||
// 分配 fat1 缓存
|
||
fat_cache.fat1.data = fat_malloc(FAT_CACHE_SIZE * 512);
|
||
if( fat_cache.fat1.data != NULL &&
|
||
os_mutex_init(&fat_cache.lock) == RET_OK &&
|
||
#ifdef FAT_TIME
|
||
os_timer_init(&fat_cache.fat_timer, fat_loop, OS_FAT_TIMER_MODE_PERIODIC, 0) == RET_OK
|
||
#else
|
||
OS_WORK_INIT(&fat_cache.fat_wk, fat_loop, 0) == RET_OK
|
||
#endif
|
||
)
|
||
{
|
||
fat_cache.fat_init = RET_OK;
|
||
FAT_INFO_SHOW("fat_init success\r\n");
|
||
#ifdef FAT_TIME
|
||
os_timer_start(&fat_cache.fat_timer, 50);
|
||
#else
|
||
os_run_work_delay(&fat_cache.fat_wk, 50);
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
os_printf("fat init err \r\n");
|
||
}
|
||
|
||
}
|
||
#endif
|
||
|
||
if (fatfs_sdh)
|
||
{
|
||
fatfs_register_drive(0, (struct fatfs_diskio*)&sdcdisk_driver, fatfs_sdh);
|
||
ret = f_mount(&fatfs[0], _SYSDSK_, 1);
|
||
if (ret)
|
||
{
|
||
printf("%s ret:%d\n", __FUNCTION__, ret);
|
||
f_mount(NULL, _SYSDSK_, 0);
|
||
return ret;
|
||
}
|
||
FAT_INFO_SHOW("f_mount success\r\n");
|
||
set_fat_ready(1);
|
||
#if USE_FAT_CACHE
|
||
init_fat_cache(&fatfs[0]);
|
||
#endif
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void fatfs_unregister()
|
||
{
|
||
int ret = 1;
|
||
FAT_INFO_SHOW(">>>>>>>>>>enter %s test\r\n", __func__);
|
||
struct sdh_device *fatfs_sdh;
|
||
fatfs_sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
if (fatfs_sdh)
|
||
{
|
||
fatfs_register_drive(0, (struct fatfs_diskio*)&sdcdisk_driver, fatfs_sdh);
|
||
ret = f_mount(NULL, _SYSDSK_, 0);
|
||
if (ret)
|
||
{
|
||
printf("%s ret:%d\n", __FUNCTION__, ret);
|
||
return;
|
||
}
|
||
set_fat_ready(0);
|
||
#if USE_FAT_CACHE
|
||
del_fat_cache();
|
||
#endif
|
||
}
|
||
}
|
||
|
||
#endif
|