21ic电子技术开发论坛 › › 技术圈 › vsf › VSF 3rd -- 移植fatfs
返回列表 发新帖

VSF 3rd -- 移植fatfs

[复制链接]
 楼主| vsfopen 发表于 2018-8-20 15:48 | 显示全部楼层 |阅读模式
FATFS, 移植, ST, AD, tv
本帖最后由 vsfopen 于 2018-8-20 15:59 编辑

fatfs的移植有2种方法：
1. 使用VSF种的mal块设备，通过独立堆栈的任务，直接调用fatfs的API来操作文件系统。
2. 把fatfs移植到VSF种的文件系统框架下，是的可以通过vsf的文件系统接口，通过fatfs来操作文件系统

第一种方式相对简单，指需要实现fatfs移植的几个口disk相关的操作接口即可：
复制
  1. static struct vsf_fatfs_internal_t
    

  2. {
    

  3.         struct
    

  4.         {
    

  5.                 struct vsfmal_t *mal;
    

  6. #if FF_FS_REENTRANT
    

  7.                 struct vsfsm_crit_t crit;
    

  8. #endif
    

  9.         } disk[VSF_FATFS_CFG_MAXVOLUME];
    

  10.         uint32_t mskarr[(VSF_FATFS_CFG_MAXVOLUME + 31) >> 5];
    

  11. } vsf_fatfs;
    


  12. 

  13. DSTATUS disk_status(BYTE pdrv)
    

  14. {
    

  15.         if (pdrv >= VSF_FATFS_CFG_MAXVOLUME) return STA_NOINIT;
    

  16.         return mskarr_get(vsf_fatfs.mskarr, pdrv) ? 0 : STA_NOINIT;
    

  17. }
    


  18. 

  19. DSTATUS disk_initialize(BYTE pdrv)
    

  20. {
    

  21.         if (disk_status(pdrv))
    

  22.                 return STA_NOINIT;
    

  23.         else
    

  24.         {
    

  25.                 struct vsfmal_t *mal = vsf_fatfs.disk[pdrv].mal;
    

  26.                 struct vsfsm_pt_t pt =
    

  27.                 {
    

  28.                         .sm = &(vsfsm_thread_get_cur())->sm,
    

  29.                         .state = 0,
    

  30.                         .user_data = mal,
    

  31.                 };
    

  32.                 vsfsm_evt_t evt = VSFSM_EVT_NONE;
    

  33.                 vsf_err_t err;
    


  34. 

  35.                 while (1)
    

  36.                 {
    

  37.                         err = vsfmal_init(&pt, evt);
    

  38.                         if (!err) break;
    

  39.                         else if (err < 0) return STA_NOINIT;
    

  40.                         else evt = vsfsm_thread_wait();
    

  41.                 }
    

  42.         }
    

  43.         return FR_OK;
    

  44. }
    


  45. 

  46. DRESULT disk_read(BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
    

  47. {
    

  48.         if (disk_status(pdrv))
    

  49.                 return RES_PARERR;
    

  50.         else
    

  51.         {
    

  52.                 struct vsfmal_t *mal = vsf_fatfs.disk[pdrv].mal;
    

  53.                 struct vsfsm_pt_t pt =
    

  54.                 {
    

  55.                         .sm = &(vsfsm_thread_get_cur())->sm,
    

  56.                         .state = 0,
    

  57.                         .user_data = mal,
    

  58.                 };
    

  59.                 vsfsm_evt_t evt = VSFSM_EVT_NONE;
    

  60.                 vsf_err_t err;
    


  61. 

  62.                 sector *= mal->cap.block_size;
    

  63.                 count *= mal->cap.block_size;
    

  64.                 while (1)
    

  65.                 {
    

  66.                         err = vsfmal_read(&pt, evt, sector, buff, count);
    

  67.                         if (!err) break;
    

  68.                         else if (err < 0) return STA_NOINIT;
    

  69.                         else evt = vsfsm_thread_wait();
    

  70.                 }
    

  71.         }
    

  72.         return FR_OK;
    

  73. }

复制
  1. int vsf_fatfs_add_disk(struct vsfmal_t *mal)
    

  2. {
    

  3.         uint8_t origlevel = vsfsm_sched_lock();
    

  4.         int idx = mskarr_ffz(vsf_fatfs.mskarr, VSF_FATFS_CFG_MAXVOLUME);
    

  5.         if (idx >= 0)
    

  6.         {
    

  7.                 mskarr_set(vsf_fatfs.mskarr, idx);
    

  8.                 vsf_fatfs.disk[idx].mal = mal;
    

  9.         }
    

  10.         vsfsm_sched_unlock(origlevel);
    

  11.         return idx;
    

  12. }
    


  13. 

  14. void vsf_fatfs_remove_disk(struct vsfmal_t *mal)
    

  15. {
    

  16.         for (int i = 0; i < VSF_FATFS_CFG_MAXVOLUME; i++)
    

  17.         {
    

  18.                 if (mskarr_get(vsf_fatfs.mskarr, i) && (mal == vsf_fatfs.disk[i].mal))
    

  19.                 {
    

  20.                         mskarr_clr(vsf_fatfs.mskarr, i);
    

  21.                         break;
    

  22.                 }
    

  23.         }
    

  24. }
通过vsf_fatfs_add_disk把VSF种的块设备，注册到vsf_fatfs模块中，并且得到对应的index序号，就可以通过序号来访问块设备里的FAT文件系统了。

由于disk_initialize的接口是阻塞的，所以应用层必须是vsfsm_thread_t的独立堆栈任务，disk_initialize里，也只是调用了PT方式的块设备驱动接口。



第二种相对麻烦一些，因为fatfs这种文件系统的应用层API过于高层，并不适合vsf的底层文件系统驱动接口。不过，可以使用fatfs的FF_FS_RPATH来实现vsf底层文件系统接口需要的相对路径功能。

复制
  1. void vsf_fatfs_run_mount(struct vsfsm_thread_t *thread)
    

  2. {
    

  3.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)thread->priv;
    

  4.         int idx = vsf_fatfs_add_disk(fatfs->mal);
    

  5.         char volume[3];
    


  6. 

  7.         if (idx < 0)
    

  8.                 return;
    


  9. 

  10.         volume[0] = '0' + idx;
    

  11.         volume[1] = ':';
    

  12.         volume[2] = '\0';
    

  13.         if (f_mount(&__fatfs, volume, 1) || f_opendir(&fatfs->root, volume))
    

  14.                 fatfs->root.obj.fs = NULL;
    

  15. }
    


  16. 

  17. static vsf_err_t vsf_fatfs_mount(struct vsfsm_pt_t *pt, vsfsm_evt_t evt,
    

  18.                 struct vsfile_t *dir)
    

  19. {
    

  20.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)pt->user_data;
    


  21. 

  22.         vsfsm_pt_begin(pt);
    

  23.         vsfsm_crit_init(&fatfs->crit, VSFSM_EVT_USER);
    

  24.         vsfsm_crit_enter(&fatfs->crit, pt->sm);
    


  25. 

  26.         fatfs->thread.op.on_terminate = vsf_fatfs_on_finish;
    

  27.         fatfs->thread.stack_size = sizeof(fatfs->stack);
    

  28.         fatfs->thread.stack = fatfs->stack;
    


  29. 

  30.         fatfs->pending_sm = pt->sm;
    

  31.         fatfs->thread.priv = fatfs;
    

  32.         fatfs->thread.op.on_run = vsf_fatfs_run_mount;
    

  33.         vsfsm_thread_start(&fatfs->thread);
    

  34.         vsfsm_pt_wfe(pt, VSFSM_EVT_USER);
    


  35. 

  36.         vsfsm_crit_leave(&fatfs->crit);
    

  37.         vsfsm_pt_end(pt);
    

  38.         return !fatfs->root.obj.fs ? VSFERR_FAIL : VSFERR_NONE;
    

  39. }
    


  40. 

  41. void vsf_fatfs_run_getchild(struct vsfsm_thread_t *thread)
    

  42. {
    

  43.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)thread->priv;
    

  44.         char *name = fatfs->getchild.name;
    

  45.         DIR *dir = fatfs->getchild.dir;
    

  46.         FILINFO fno;
    


  47. 

  48.         fatfs->getchild.file = NULL;
    

  49.         while (1)
    

  50.         {
    

  51.                 if (f_readdir(dir, &fno) || !fno.fname[0])
    

  52.                         break;
    


  53. 

  54.                 if (vsfile_match(name, fno.fname))
    

  55.                 {
    

  56.                         struct vsf_fatfs_file_t *file;
    

  57.                         uint32_t fname_len = strlen(fno.fname) + 1;
    

  58.                         uint32_t entry_len = fno.fattrib & AM_DIR ? sizeof(DIR) : sizeof(FIL);
    

  59.                         uint32_t size = sizeof(*file) + entry_len + fname_len;
    


  60. 

  61.                         file = vsf_bufmgr_malloc(size);
    

  62.                         if (file != NULL)
    

  63.                         {
    

  64.                                 file->entry.ptr = &file[1];
    

  65.                                 file->file.name = (char *)file->entry.ptr + entry_len;
    


  66. 

  67.                                 strcpy(file->file.name, fno.fname);
    

  68.                                 file->file.attr = fno.fattrib;
    

  69.                                 file->file.op = &vsf_fatfs_fsop;
    

  70.                                 file->file.size = fno.fsize;
    


  71. 

  72.                                 __fatfs.cdir = dir->obj.sclust;
    

  73.                                 if (file->file.attr & VSFILE_ATTR_DIRECTORY)
    

  74.                                 {
    

  75.                                         DIR *dp = file->entry.d;
    

  76.                                         if (f_opendir(dp, file->file.name))
    

  77.                                                 return;
    

  78.                                 }
    

  79.                                 else
    

  80.                                 {
    

  81.                                         FIL *fp = file->entry.f;
    

  82.                                         if (f_open(fp, file->file.name, 1))
    

  83.                                                 return;
    

  84.                                 }
    


  85. 

  86.                                 fatfs->getchild.file = file;
    

  87.                         }
    

  88.                         break;
    

  89.                 }
    

  90.         }
    

  91. }
    


  92. 

  93. static vsf_err_t vsf_fatfs_getchild(struct vsfsm_pt_t *pt, vsfsm_evt_t evt,
    

  94.                 struct vsfile_t *dir, char *name, uint32_t idx, struct vsfile_t **file)
    

  95. {
    

  96.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)pt->user_data;
    


  97. 

  98.         vsfsm_pt_begin(pt);
    

  99.         if (vsfsm_crit_enter(&fatfs->crit, pt->sm))
    

  100.                 vsfsm_pt_wfe(pt, VSFSM_EVT_USER);
    


  101. 

  102.         fatfs->getchild.dir = ((struct vsf_fatfs_file_t *)dir)->entry.d;
    

  103.         if (!fatfs->getchild.dir)
    

  104.                 fatfs->getchild.dir = &fatfs->root;
    

  105.         fatfs->getchild.name = name;
    


  106. 

  107.         fatfs->pending_sm = pt->sm;
    

  108.         fatfs->thread.priv = fatfs;
    

  109.         fatfs->thread.op.on_run = vsf_fatfs_run_getchild;
    

  110.         vsfsm_thread_start(&fatfs->thread);
    

  111.         vsfsm_pt_wfe(pt, VSFSM_EVT_USER);
    

  112.         *file = &fatfs->getchild.file->file;
    


  113. 

  114.         vsfsm_crit_leave(&fatfs->crit);
    

  115.         vsfsm_pt_end(pt);
    

  116.         return VSFERR_NONE;
    

  117. }
    


  118. 

  119. void vsf_fatfs_run_read(struct vsfsm_thread_t *thread)
    

  120. {
    

  121.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)thread->priv;
    

  122.         struct vsf_fatfs_file_t *file = fatfs->close.file;
    


  123. 

  124.         fatfs->rw.rw_size = 0;
    

  125.         if (!f_lseek(file->entry.f, fatfs->rw.offset))
    

  126.                 f_read(file->entry.f, fatfs->rw.buff, fatfs->rw.size, &fatfs->rw.rw_size);
    

  127. }
    


  128. 

  129. static vsf_err_t vsf_fatfs_read(struct vsfsm_pt_t *pt, vsfsm_evt_t evt,
    

  130.                 struct vsfile_t *file, uint64_t offset, uint32_t size, uint8_t *buff,
    

  131.                 uint32_t *rsize)
    

  132. {
    

  133.         struct vsf_fatfs_t *fatfs = (struct vsf_fatfs_t *)pt->user_data;
    


  134. 

  135.         vsfsm_pt_begin(pt);
    

  136.         if (vsfsm_crit_enter(&fatfs->crit, pt->sm))
    

  137.                 vsfsm_pt_wfe(pt, VSFSM_EVT_USER);
    


  138. 

  139.         fatfs->rw.file = (struct vsf_fatfs_file_t *)file;
    

  140.         fatfs->rw.buff = buff;
    

  141.         fatfs->rw.offset = offset;
    

  142.         fatfs->rw.size = size;
    


  143. 

  144.         fatfs->pending_sm = pt->sm;
    

  145.         fatfs->thread.priv = fatfs;
    

  146.         fatfs->thread.op.on_run = vsf_fatfs_run_read;
    

  147.         vsfsm_thread_start(&fatfs->thread);
    

  148.         vsfsm_pt_wfe(pt, VSFSM_EVT_USER);
    

  149.         if (rsize != NULL)
    

  150.                 *rsize = fatfs->rw.rw_size;
    


  151. 

  152.         vsfsm_crit_leave(&fatfs->crit);
    

  153.         vsfsm_pt_end(pt);
    

  154.         return VSFERR_NONE;
    

  155. }

vsf_fatfs_mount、vsf_fatfs_getchild、vsf_fatfs_read等等接口是VSF的文件系统驱动的接口，是PT形式的任务。由于fatfs需要使用vsfsm_thread_t形式的任务，所以在这些接口里，只是简单的设置了参数，并且启动对应的vsfsm_thread_t任务，并等待执行完成，返回结果。

其中，mount和读写等接口相对简单，直接调用fatfs对应的API即可。不过，vsf的文件系统有一个getchild接口，用于得到指定目录下，指定的文件或者子目录。这个接口就需要相对的路径，fatfs正好可以通过FF_FS_RPATH来使能相对路径，但是f_chdir接口仍旧需要绝对路径，所以i这里就只是简单的通过设置fatfs.cdir来设置当前的目录，然后就后面的路径就是基于这个当前目录的相对路径。

注意：一些中间参数和变量（包括vsfsm_thread_t）会放在fatfs的结构中，所以，调用这些接口的时候，需要保证其他任务不对调用，以避免资源使用的冲突，这里使用了一个vsfsm_crit_t来避免这个问题。所以，所有这些PT的文件系统接口，会先做保护，然后再使用共享资源。
回复

举报

相关帖子
ayong147 发表于 2020-2-22 19:58 | 显示全部楼层
先看看怎么样！
回复

举报

返回列表 发新帖
vsfopen

90

主题

325

帖子

8

粉丝
快速回复 在线客服 返回列表 返回顶部