ff.h

/*----------------------------------------------------------------------------/
/  FatFs - Generic FAT Filesystem module  R0.14                               /
/-----------------------------------------------------------------------------/
/
/ Copyright (C) 2019, ChaN, all right reserved.
/
/ FatFs module is an open source software. Redistribution and use of FatFs in
/ source and binary forms, with or without modification, are permitted provided
/ that the following condition is met:
 
/ 1. Redistributions of source code must retain the above copyright notice,
/    this condition and the following disclaimer.
/
/ This software is provided by the copyright holder and contributors "AS IS"
/ and any warranties related to this software are DISCLAIMED.
/ The copyright owner or contributors be NOT LIABLE for any damages caused
/ by use of this software.
/
/----------------------------------------------------------------------------*/
 
#pragma once
#include <cstdlib>
#include "ffconf.h"  // FatFs configuration options
#include "ffdef.h"   // common structures and defines
#include "driver/IO.h"
 
namespace fatfs {
 
class FatFs {
 public:
  FatFs() = default;
  FatFs(IO& io) { setDriver(io); }
  void setDriver(IO& io) { p_io = &io; }
  IO* getDriver() {return p_io;}
  FRESULT f_open(FIL* fp, const TCHAR* path,
                 BYTE mode); 
  FRESULT f_close(FIL* fp);  
  FRESULT f_read(FIL* fp, void* buff, UINT btr,
                 UINT* br); 
  FRESULT f_write(FIL* fp, const void* buff, UINT btw,
                  UINT* bw); 
  FRESULT f_lseek(FIL* fp,
                  FSIZE_t ofs); 
  FRESULT f_truncate(FIL* fp);  
  FRESULT f_sync(FIL* fp);      
  FRESULT f_opendir(DIR* dp, const TCHAR* path); 
  FRESULT f_closedir(DIR* dp);                   
  FRESULT f_readdir(DIR* dp, FILINFO* fno);      
  FRESULT f_findfirst(DIR* dp, FILINFO* fno, const TCHAR* path,
                      const TCHAR* pattern); 
  FRESULT f_findnext(DIR* dp, FILINFO* fno); 
  FRESULT f_mkdir(const TCHAR* path);        
  FRESULT f_unlink(
      const TCHAR* path); 
  FRESULT f_rename(const TCHAR* path_old,
                   const TCHAR* path_new); 
  FRESULT f_stat(const TCHAR* path, FILINFO* fno); 
  FRESULT f_chmod(const TCHAR* path, BYTE attr,
                  BYTE mask); 
  FRESULT f_utime(const TCHAR* path,
                  const FILINFO* fno);     
  FRESULT f_chdir(const TCHAR* path);      
  FRESULT f_chdrive(const TCHAR* path);    
  FRESULT f_getcwd(TCHAR* buff, UINT len); 
  FRESULT f_getfree(
      const TCHAR* path, DWORD* nclst,
      FATFS** fatfs); 
  FRESULT f_getlabel(const TCHAR* path, TCHAR* label,
                     DWORD* vsn);         
  FRESULT f_setlabel(const TCHAR* label); 
  FRESULT f_forward(FIL* fp, UINT (*func)(const BYTE*, UINT), UINT btf,
                    UINT* bf); 
  FRESULT f_expand(FIL* fp, FSIZE_t fsz,
                   BYTE opt); 
  FRESULT f_mount(FATFS* fs, const TCHAR* path,
                  BYTE opt); 
  FRESULT f_mkfs(const TCHAR* path, const MKFS_PARM* opt, void* work,
                 UINT len); 
  FRESULT f_fdisk(
      BYTE pdrv, const LBA_t ptbl[],
      void* work);          
  FRESULT f_setcp(WORD cp); 
  int f_putc(TCHAR c, FIL* fp);          
  int f_puts(const TCHAR* str, FIL* cp); 
  int f_printf(FIL* fp, const TCHAR* str,
               ...); 
  TCHAR* f_gets(TCHAR* buff, int len, FIL* fp); 
  inline bool f_eof(FIL* fp) {
    return ((int)((fp)->fptr == (fp)->obj.objsize));
  }
  inline BYTE f_error(FIL* fp) { return ((fp)->err); }
  inline FSIZE_t f_tell(FIL* fp) { return ((fp)->fptr); }
  inline FSIZE_t f_size(FIL* fp) { return ((fp)->obj.objsize); }
  inline FRESULT f_rewind(FIL* fp) { return f_lseek((fp), 0); }
  inline FRESULT f_rewinddir(DIR* dp) { return f_readdir((dp), 0); }
  inline FRESULT f_rmdir(const TCHAR* path) { return f_unlink(path); }
  inline FRESULT f_unmount(const TCHAR* path) { return f_mount(0, path, 0); }
 
/*--------------------------------------------------------------*/
/* Additional user defined functions                            */
 
/* RTC function */
#if !FF_FS_READONLY && !FF_FS_NORTC
  DWORD get_fattime(void);
#endif
 
#if FF_FS_REENTRANT
  int ff_cre_syncobj(BYTE vol, FF_SYNC_t* sobj); 
  int ff_req_grant(FF_SYNC_t sobj);              
  void ff_rel_grant(FF_SYNC_t sobj);             
  int ff_del_syncobj(FF_SYNC_t sobj);            
#endif
 
 protected:
  IO* p_io = nullptr;
 
  /*--------------------------------------------------------------------------
 
     Module Private Work Area
 
  ---------------------------------------------------------------------------*/
  /* Remark: Variables defined here without initial value shall be guaranteed
  /  zero/null at start-up. If not, the linker option or start-up routine is
  /  not compliance with C standard. */
 
  /*--------------------------------*/
  /* File/Volume controls           */
  /*--------------------------------*/
 
#if FF_VOLUMES < 1 || FF_VOLUMES > 10
#error Wrong FF_VOLUMES setting
#endif
  FATFS* FatFsDir[FF_VOLUMES]; 
  WORD Fsid;                   
#if FF_FS_RPATH != 0
  BYTE CurrVol; 
#endif
 
#if FF_FS_LOCK != 0
  FILESEM Files[FF_FS_LOCK]; 
#endif
 
#if FF_STR_VOLUME_ID
#ifdef FF_VOLUME_STRS
  const char* const VolumeStr[FF_VOLUMES] = {
      FF_VOLUME_STRS}; 
#endif
#endif
 
#if FF_LBA64
#if FF_MIN_GPT > 0x100000000
#error Wrong FF_MIN_GPT setting
#endif
  const BYTE GUID_MS_Basic[16] = {0xA2, 0xA0, 0xD0, 0xEB, 0xE5, 0xB9,
                                  0x33, 0x44, 0x87, 0xC0, 0x68, 0xB6,
                                  0xB7, 0x26, 0x99, 0xC7};
#endif
 
  /*--------------------------------*/
  /* LFN/Directory working buffer   */
  /*--------------------------------*/
 
#if FF_USE_LFN == 0 
#if FF_FS_EXFAT
#error LFN must be enabled when enable exFAT
#endif
#define DEF_NAMBUF
#define INIT_NAMBUF(fs)
#define FREE_NAMBUF()
#define LEAVE_MKFS(res) return res
 
#else 
#if FF_MAX_LFN < 12 || FF_MAX_LFN > 255
#error Wrong setting of FF_MAX_LFN
#endif
#if FF_LFN_BUF < FF_SFN_BUF || FF_SFN_BUF < 12
#error Wrong setting of FF_LFN_BUF or FF_SFN_BUF
#endif
#if FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3
#error Wrong setting of FF_LFN_UNICODE
#endif
  const BYTE LfnOfs[13] = {
      1,  3,  5,  7,  9,  14, 16,
      18, 20, 22, 24, 28, 30}; 
#define MAXDIRB(nc)                                                         \
  ((nc + 44U) / 15 *                                                        \
   SZDIRE) 
#if FF_USE_LFN == 1 
#if FF_FS_EXFAT
  BYTE
      DirBuf[MAXDIRB(FF_MAX_LFN)]; 
#endif
  WCHAR LfnBuf[FF_MAX_LFN + 1]; 
#define DEF_NAMBUF
#define INIT_NAMBUF(fs)
#define FREE_NAMBUF()
#define LEAVE_MKFS(res) return res
 
#elif FF_USE_LFN == 2 
#if FF_FS_EXFAT
#define DEF_NAMBUF                                                          \
  WCHAR lbuf[FF_MAX_LFN + 1];                                               \
  BYTE dbuf[MAXDIRB(FF_MAX_LFN)]; 
#define INIT_NAMBUF(fs)  \
  {                      \
    (fs)->lfnbuf = lbuf; \
    (fs)->dirbuf = dbuf; \
  }
#define FREE_NAMBUF()
#else // !FF_FS_EXFAT
#define DEF_NAMBUF WCHAR lbuf[FF_MAX_LFN + 1]; 
#define INIT_NAMBUF(fs) \
  { (fs)->lfnbuf = lbuf; }
#define FREE_NAMBUF()
#endif // FF_FS_EXFAT
 
#define LEAVE_MKFS(res) return res
 
#elif FF_USE_LFN == 3 
#if FF_FS_EXFAT
#define DEF_NAMBUF                                                       \
  WCHAR* lfn; 
#define INIT_NAMBUF(fs)                                            \
  {                                                                \
    lfn = ff_memalloc((FF_MAX_LFN + 1) * 2 + MAXDIRB(FF_MAX_LFN)); \
    if (!lfn) LEAVE_FF(fs, FR_NOT_ENOUGH_CORE);                    \
    (fs)->lfnbuf = lfn;                                            \
    (fs)->dirbuf = (BYTE*)(lfn + FF_MAX_LFN + 1);                  \
  }
#define FREE_NAMBUF() ff_memfree(lfn)
#else
#define DEF_NAMBUF WCHAR* lfn; 
#define INIT_NAMBUF(fs)                         \
  {                                             \
    lfn = ff_memalloc((FF_MAX_LFN + 1) * 2);    \
    if (!lfn) LEAVE_FF(fs, FR_NOT_ENOUGH_CORE); \
    (fs)->lfnbuf = lfn;                         \
  }
#define FREE_NAMBUF() ff_memfree(lfn)
#endif
#define LEAVE_MKFS(res)         \
  {                             \
    if (!work) ff_memfree(buf); \
    return res;                 \
  }
#define MAX_MALLOC 0x8000 
#else
#error Wrong setting of FF_USE_LFN
#endif 
#endif 
  void flush(putbuff* pb);
  void putc_bfd(putbuff* pb, TCHAR c);
  int putc_flush(putbuff* pb);
  FRESULT validate(FFOBJID* obj, FATFS** rfs);
  FRESULT sync_window(FATFS* fs);
  FRESULT move_window(FATFS* fs, LBA_t sect);
  FRESULT sync_fs(FATFS* fs);
  DWORD get_fat(FFOBJID* obj, DWORD clst);
  FRESULT put_fat(FATFS* fs, DWORD clst, DWORD val);
  DWORD find_bitmap(FATFS* fs, DWORD clst, DWORD ncl);
  FRESULT remove_chain(FFOBJID* obj, DWORD clst, DWORD pclst);
  DWORD create_chain(FFOBJID* obj, DWORD clst);
  FRESULT dir_clear(FATFS* fs, DWORD clst);
  FRESULT dir_sdi(DIR* dp, DWORD ofs);
  FRESULT dir_next(DIR* dp, int stretch);
  FRESULT dir_alloc(DIR* dp, UINT nent);
  FRESULT dir_read(DIR* dp, int vol);
  FRESULT dir_find(DIR* dp);
  FRESULT dir_register(DIR* dp);
  FRESULT dir_remove(DIR* dp);
  FRESULT follow_path(DIR* dp, const TCHAR* path);
  UINT check_fs(FATFS* fs, LBA_t sect);
  UINT find_volume(FATFS* fs, UINT part);
  FRESULT mount_volume(const TCHAR** path, FATFS** rfs, BYTE mode);
  int cmp_lfn(const WCHAR* lfnbuf, BYTE* dir);
  int pick_lfn(WCHAR* lfnbuf, BYTE* dir);
  void put_lfn(const WCHAR* lfn, BYTE* dir, BYTE ord, BYTE sum);
  FRESULT create_partition(BYTE drv, const LBA_t plst[], UINT sys, BYTE* buf);
  FRESULT change_bitmap(FATFS* fs, DWORD clst, DWORD ncl, int bv);
  FRESULT fill_first_frag(FFOBJID* obj);
  FRESULT fill_last_frag(FFOBJID* obj, DWORD lcl, DWORD term);
  FRESULT load_xdir(DIR* dp);
  FRESULT load_obj_xdir(DIR* dp, const FFOBJID* obj);
  FRESULT store_xdir(DIR*);
  FRESULT chk_lock(DIR* dp, int acc);
  int enq_lock(void);
  UINT inc_lock(DIR* dp, int acc);
  FRESULT dec_lock(UINT i);
  void clear_lock(FATFS* fs);
 
#if FF_USE_LFN == 3 
  /*------------------------------------------------------------------------*/
  /* Allocate a memory block */
  /*------------------------------------------------------------------------*/
 
  void* ff_memalloc(
                    UINT msize 
  ) {
    return malloc(msize); 
  }
 
  /*------------------------------------------------------------------------*/
  /* Free a memory block                                                    */
  /*------------------------------------------------------------------------*/
 
  void ff_memfree(void* mblock 
  ) {
    free(mblock); 
  }
 
#endif
};
 
/* LFN support functions */
#if FF_USE_LFN >= 1 
WCHAR ff_oem2uni(WCHAR oem, WORD cp); 
WCHAR ff_uni2oem(DWORD uni, WORD cp); 
DWORD ff_wtoupper(DWORD uni);         
#endif
 
}  // namespace fatfs
 
// Header-only library: include implementations
#ifndef FATFS_HEADER_ONLY_IMPL
#define FATFS_HEADER_ONLY_IMPL
 
// Include FatFs core implementation
#include "ff-inc.h"
 
// Include system functions (memory allocation, locking)
#include "ffsystem-inc.h"
 
// Include Unicode conversion tables (if LFN support enabled)
#if FF_USE_LFN >= 1
#include "ffunicode-inc.h"
#endif
 
#endif  // FATFS_HEADER_ONLY_IMPL