?login_element?

Subversion Repositories NedoOS

Rev

Rev 8 | Blame | Compare with Previous | Last modification | View Log | Download

  1. /*----------------------------------------------------------------------------/
  2. /  FatFs - Generic FAT Filesystem module  R0.13c                              /
  3. /-----------------------------------------------------------------------------/
  4. /
  5. / Copyright (C) 2018, ChaN, all right reserved.
  6. /
  7. / FatFs module is an open source software. Redistribution and use of FatFs in
  8. / source and binary forms, with or without modification, are permitted provided
  9. / that the following condition is met:
  10.  
  11. / 1. Redistributions of source code must retain the above copyright notice,
  12. /    this condition and the following disclaimer.
  13. /
  14. / This software is provided by the copyright holder and contributors "AS IS"
  15. / and any warranties related to this software are DISCLAIMED.
  16. / The copyright owner or contributors be NOT LIABLE for any damages caused
  17. / by use of this software.
  18. /
  19. /----------------------------------------------------------------------------*/
  20.  
  21.  
  22. #ifndef FF_DEFINED
  23. #define FF_DEFINED      86604   /* Revision ID */
  24.  
  25. #ifdef __cplusplus
  26. extern "C" {
  27. #endif
  28.  
  29. #include "ffconf.h"             /* FatFs configuration options */
  30.  
  31. #if FF_DEFINED != FFCONF_DEF
  32. #error Wrong configuration file (ffconf.h).
  33. #endif
  34.  
  35.  
  36. /* Integer types used for FatFs API */
  37.  
  38. #if defined(_WIN32)     /* Main development platform */
  39. #define FF_INTDEF 2
  40. #include <windows.h>
  41. typedef unsigned __int64 QWORD;
  42. #elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)        /* C99 or later */
  43. #define FF_INTDEF 2
  44. #include <stdint.h>
  45. typedef unsigned int    UINT;   /* int must be 16-bit or 32-bit */
  46. typedef unsigned char   BYTE;   /* char must be 8-bit */
  47. typedef uint16_t                WORD;   /* 16-bit unsigned integer */
  48. typedef uint16_t                WCHAR;  /* 16-bit unsigned integer */
  49. typedef uint32_t                DWORD;  /* 32-bit unsigned integer */
  50. typedef uint64_t                QWORD;  /* 64-bit unsigned integer */
  51. #else   /* Earlier than C99 */
  52. #define FF_INTDEF 1
  53. typedef unsigned int    UINT;   /* int must be 16-bit or 32-bit */
  54. typedef unsigned char   BYTE;   /* char must be 8-bit */
  55. typedef unsigned short  WORD;   /* 16-bit unsigned integer */
  56. typedef unsigned short  WCHAR;  /* 16-bit unsigned integer */
  57. typedef unsigned long   DWORD;  /* 32-bit unsigned integer */
  58. #endif
  59.  
  60.  
  61. /* Definitions of volume management */
  62.  
  63. #if FF_MULTI_PARTITION          /* Multiple partition configuration */
  64. typedef struct {
  65.         BYTE pd;        /* Physical drive number */
  66.         BYTE pt;        /* Partition: 0:Auto detect, 1-4:Forced partition) */
  67. } PARTITION;
  68. extern PARTITION VolToPart[];   /* Volume - Partition resolution table */
  69. #endif
  70.  
  71. #if FF_STR_VOLUME_ID
  72. #ifndef FF_VOLUME_STRS
  73. extern const char* VolumeStr[FF_VOLUMES];       /* User defied volume ID */
  74. #endif
  75. #endif
  76.  
  77.  
  78.  
  79. /* Type of path name strings on FatFs API */
  80.  
  81. #ifndef _INC_TCHAR
  82. #define _INC_TCHAR
  83.  
  84. #if FF_USE_LFN && FF_LFN_UNICODE == 1   /* Unicode in UTF-16 encoding */
  85. typedef WCHAR TCHAR;
  86. #define _T(x) L ## x
  87. #define _TEXT(x) L ## x
  88. #elif FF_USE_LFN && FF_LFN_UNICODE == 2 /* Unicode in UTF-8 encoding */
  89. typedef char TCHAR;
  90. #define _T(x) u8 ## x
  91. #define _TEXT(x) u8 ## x
  92. #elif FF_USE_LFN && FF_LFN_UNICODE == 3 /* Unicode in UTF-32 encoding */
  93. typedef DWORD TCHAR;
  94. #define _T(x) U ## x
  95. #define _TEXT(x) U ## x
  96. #elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
  97. #error Wrong FF_LFN_UNICODE setting
  98. #else                                                                   /* ANSI/OEM code in SBCS/DBCS */
  99. typedef char TCHAR;
  100. #define _T(x) x
  101. #define _TEXT(x) x
  102. #endif
  103.  
  104. #endif
  105.  
  106.  
  107.  
  108. /* Type of file size variables */
  109.  
  110. #if FF_FS_EXFAT
  111. #if FF_INTDEF != 2
  112. #error exFAT feature wants C99 or later
  113. #endif
  114. typedef QWORD FSIZE_t;
  115. #else
  116. typedef DWORD FSIZE_t;
  117. #endif
  118.  
  119.  
  120.  
  121. /* Filesystem object structure (FATFS) */
  122.  
  123. typedef struct {
  124.         BYTE    fs_type;                /* Filesystem type (0:not mounted) */
  125.         BYTE    pdrv;                   /* Associated physical drive */
  126.         BYTE    n_fats;                 /* Number of FATs (1 or 2) */
  127.         BYTE    wflag;                  /* win[] flag (b0:dirty) */
  128.         BYTE    fsi_flag;               /* FSINFO flags (b7:disabled, b0:dirty) */
  129.         WORD    id;                             /* Volume mount ID */
  130.         WORD    n_rootdir;              /* Number of root directory entries (FAT12/16) */
  131.         WORD    csize;                  /* Cluster size [sectors] */
  132. #if FF_MAX_SS != FF_MIN_SS
  133.         WORD    ssize;                  /* Sector size (512, 1024, 2048 or 4096) */
  134. #endif
  135. #if FF_USE_LFN
  136.         WCHAR*  lfnbuf;                 /* LFN working buffer */
  137. #endif
  138. #if FF_FS_EXFAT
  139.         BYTE*   dirbuf;                 /* Directory entry block scratchpad buffer for exFAT */
  140. #endif
  141. #if FF_FS_REENTRANT
  142.         FF_SYNC_t       sobj;           /* Identifier of sync object */
  143. #endif
  144. #if !FF_FS_READONLY
  145.         DWORD   last_clst;              /* Last allocated cluster */
  146.         DWORD   free_clst;              /* Number of free clusters */
  147. #endif
  148. #if FF_FS_RPATH
  149.         DWORD   cdir;                   /* Current directory start cluster (0:root) */
  150. #if FF_FS_EXFAT
  151.         DWORD   cdc_scl;                /* Containing directory start cluster (invalid when cdir is 0) */
  152.         DWORD   cdc_size;               /* b31-b8:Size of containing directory, b7-b0: Chain status */
  153.         DWORD   cdc_ofs;                /* Offset in the containing directory (invalid when cdir is 0) */
  154. #endif
  155. #endif
  156.         DWORD   n_fatent;               /* Number of FAT entries (number of clusters + 2) */
  157.         DWORD   fsize;                  /* Size of an FAT [sectors] */
  158.         DWORD   volbase;                /* Volume base sector */
  159.         DWORD   fatbase;                /* FAT base sector */
  160.         DWORD   dirbase;                /* Root directory base sector/cluster */
  161.         DWORD   database;               /* Data base sector */
  162. #if FF_FS_EXFAT
  163.         DWORD   bitbase;                /* Allocation bitmap base sector */
  164. #endif
  165.         DWORD   winsect;                /* Current sector appearing in the win[] */
  166.         BYTE    win[FF_MAX_SS]; /* Disk access window for Directory, FAT (and file data at tiny cfg) */
  167. } FATFS;
  168.  
  169.  
  170.  
  171. /* Object ID and allocation information (FFOBJID) */
  172.  
  173. typedef struct {
  174.         FATFS*  fs;                             /* Pointer to the hosting volume of this object */
  175.         WORD    id;                             /* Hosting volume mount ID */
  176.         BYTE    attr;                   /* Object attribute */
  177.         BYTE    stat;                   /* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
  178.         DWORD   sclust;                 /* Object data start cluster (0:no cluster or root directory) */
  179.         FSIZE_t objsize;                /* Object size (valid when sclust != 0) */
  180. #if FF_FS_EXFAT
  181.         DWORD   n_cont;                 /* Size of first fragment - 1 (valid when stat == 3) */
  182.         DWORD   n_frag;                 /* Size of last fragment needs to be written to FAT (valid when not zero) */
  183.         DWORD   c_scl;                  /* Containing directory start cluster (valid when sclust != 0) */
  184.         DWORD   c_size;                 /* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
  185.         DWORD   c_ofs;                  /* Offset in the containing directory (valid when file object and sclust != 0) */
  186. #endif
  187. #if FF_FS_LOCK
  188.         UINT    lockid;                 /* File lock ID origin from 1 (index of file semaphore table Files[]) */
  189. #endif
  190. } FFOBJID;
  191.  
  192.  
  193.  
  194. /* File object structure (FIL) */
  195.  
  196. typedef struct {
  197.         FFOBJID obj;                    /* Object identifier (must be the 1st member to detect invalid object pointer) */
  198.         BYTE    flag;                   /* File status flags */
  199.         BYTE    err;                    /* Abort flag (error code) */
  200.         FSIZE_t fptr;                   /* File read/write pointer (Zeroed on file open) */
  201.         DWORD   clust;                  /* Current cluster of fpter (invalid when fptr is 0) */
  202.         DWORD   sect;                   /* Sector number appearing in buf[] (0:invalid) */
  203. #if !FF_FS_READONLY
  204.         DWORD   dir_sect;               /* Sector number containing the directory entry (not used at exFAT) */
  205.         BYTE*   dir_ptr;                /* Pointer to the directory entry in the win[] (not used at exFAT) */
  206. #endif
  207. #if FF_USE_FASTSEEK
  208.         DWORD*  cltbl;                  /* Pointer to the cluster link map table (nulled on open, set by application) */
  209. #endif
  210. #if !FF_FS_TINY
  211.         BYTE    buf[FF_MAX_SS]; /* File private data read/write window */
  212. #endif
  213. } FIL;
  214.  
  215.  
  216.  
  217. /* Directory object structure (DIR) */
  218.  
  219. typedef struct {
  220.         FFOBJID obj;                    /* Object identifier */
  221.         DWORD   dptr;                   /* Current read/write offset */
  222.         DWORD   clust;                  /* Current cluster */
  223.         DWORD   sect;                   /* Current sector (0:Read operation has terminated) */
  224.         BYTE*   dir;                    /* Pointer to the directory item in the win[] */
  225.         BYTE    fn[12];                 /* SFN (in/out) {body[8],ext[3],status[1]} */
  226. #if FF_USE_LFN
  227.         DWORD   blk_ofs;                /* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
  228. #endif
  229. #if FF_USE_FIND
  230.         const TCHAR* pat;               /* Pointer to the name matching pattern */
  231. #endif
  232. } DIR;
  233.  
  234.  
  235.  
  236. /* File information structure (FILINFO) */
  237.  
  238. typedef struct {
  239.         FSIZE_t fsize;                  /* File size */
  240.         WORD    fdate;                  /* Modified date */
  241.         WORD    ftime;                  /* Modified time */
  242.         BYTE    fattrib;                /* File attribute */
  243. #if FF_USE_LFN
  244.         TCHAR   altname[FF_SFN_BUF + 1];/* Altenative file name */
  245.         TCHAR   fname[FF_LFN_BUF + 1];  /* Primary file name */
  246. #else
  247.         TCHAR   fname[12 + 1];  /* File name */
  248. #endif
  249. } FILINFO;
  250.  
  251.  
  252.  
  253. /* File function return code (FRESULT) */
  254.  
  255. typedef enum {
  256.         FR_OK = 0,                              /* (0) Succeeded */
  257.         FR_DISK_ERR,                    /* (1) A hard error occurred in the low level disk I/O layer */
  258.         FR_INT_ERR,                             /* (2) Assertion failed */
  259.         FR_NOT_READY,                   /* (3) The physical drive cannot work */
  260.         FR_NO_FILE,                             /* (4) Could not find the file */
  261.         FR_NO_PATH,                             /* (5) Could not find the path */
  262.         FR_INVALID_NAME,                /* (6) The path name format is invalid */
  263.         FR_DENIED,                              /* (7) Access denied due to prohibited access or directory full */
  264.         FR_EXIST,                               /* (8) Access denied due to prohibited access */
  265.         FR_INVALID_OBJECT,              /* (9) The file/directory object is invalid */
  266.         FR_WRITE_PROTECTED,             /* (10) The physical drive is write protected */
  267.         FR_INVALID_DRIVE,               /* (11) The logical drive number is invalid */
  268.         FR_NOT_ENABLED,                 /* (12) The volume has no work area */
  269.         FR_NO_FILESYSTEM,               /* (13) There is no valid FAT volume */
  270.         FR_MKFS_ABORTED,                /* (14) The f_mkfs() aborted due to any problem */
  271.         FR_TIMEOUT,                             /* (15) Could not get a grant to access the volume within defined period */
  272.         FR_LOCKED,                              /* (16) The operation is rejected according to the file sharing policy */
  273.         FR_NOT_ENOUGH_CORE,             /* (17) LFN working buffer could not be allocated */
  274.         FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > FF_FS_LOCK */
  275.         FR_INVALID_PARAMETER    /* (19) Given parameter is invalid */
  276. } FRESULT;
  277.  
  278.  
  279.  
  280. /*--------------------------------------------------------------*/
  281. /* FatFs module application interface                           */
  282.  
  283. FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);                         /* Open or create a file */
  284. FRESULT f_close (FIL* fp);                                                                                      /* Close an open file object */
  285. FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);                       /* Read data from the file */
  286. FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);        /* Write data to the file */
  287. FRESULT f_lseek (FIL* fp, FSIZE_t ofs);                                                         /* Move file pointer of the file object */
  288. FRESULT f_truncate (FIL* fp);                                                                           /* Truncate the file */
  289. FRESULT f_sync (FIL* fp);                                                                                       /* Flush cached data of the writing file */
  290. FRESULT f_opendir (DIR* dp, const TCHAR* path);                                         /* Open a directory */
  291. FRESULT f_closedir (DIR* dp);                                                                           /* Close an open directory */
  292. FRESULT f_readdir (DIR* dp, FILINFO* fno);                                                      /* Read a directory item */
  293. FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);   /* Find first file */
  294. FRESULT f_findnext (DIR* dp, FILINFO* fno);                                                     /* Find next file */
  295. FRESULT f_mkdir (const TCHAR* path);                                                            /* Create a sub directory */
  296. FRESULT f_unlink (const TCHAR* path);                                                           /* Delete an existing file or directory */
  297. FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);        /* Rename/Move a file or directory */
  298. FRESULT f_stat (const TCHAR* path, FILINFO* fno);                                       /* Get file status */
  299. FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);                      /* Change attribute of a file/dir */
  300. FRESULT f_utime (const TCHAR* path, const FILINFO* fno);                        /* Change timestamp of a file/dir */
  301. FRESULT f_chdir (const TCHAR* path);                                                            /* Change current directory */
  302. FRESULT f_chdrive (const TCHAR* path);                                                          /* Change current drive */
  303. FRESULT f_getcwd (TCHAR* buff, UINT len);                                                       /* Get current directory */
  304. FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);     /* Get number of free clusters on the drive */
  305. FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);       /* Get volume label */
  306. FRESULT f_setlabel (const TCHAR* label);                                                        /* Set volume label */
  307. FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */
  308. FRESULT f_expand (FIL* fp, FSIZE_t szf, BYTE opt);                                      /* Allocate a contiguous block to the file */
  309. FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);                       /* Mount/Unmount a logical drive */
  310. FRESULT f_mkfs (const TCHAR* path, BYTE opt, DWORD au, void* work, UINT len);   /* Create a FAT volume */
  311. FRESULT f_fdisk (BYTE pdrv, const DWORD* szt, void* work);                      /* Divide a physical drive into some partitions */
  312. FRESULT f_setcp (WORD cp);                                                                                      /* Set current code page */
  313. int f_putc (TCHAR c, FIL* fp);                                                                          /* Put a character to the file */
  314. int f_puts (const TCHAR* str, FIL* cp);                                                         /* Put a string to the file */
  315. int f_printf (FIL* fp, const TCHAR* str, ...);                                          /* Put a formatted string to the file */
  316. TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);                                          /* Get a string from the file */
  317.  
  318. #define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
  319. #define f_error(fp) ((fp)->err)
  320. #define f_tell(fp) ((fp)->fptr)
  321. #define f_size(fp) ((fp)->obj.objsize)
  322. #define f_rewind(fp) f_lseek((fp), 0)
  323. #define f_rewinddir(dp) f_readdir((dp), 0)
  324. #define f_rmdir(path) f_unlink(path)
  325. #define f_unmount(path) f_mount(0, path, 0)
  326.  
  327. #ifndef EOF
  328. #define EOF (-1)
  329. #endif
  330.  
  331.  
  332.  
  333.  
  334. /*--------------------------------------------------------------*/
  335. /* Additional user defined functions                            */
  336.  
  337. /* RTC function */
  338. #if !FF_FS_READONLY && !FF_FS_NORTC
  339. DWORD get_fattime (void);
  340. #endif
  341.  
  342. /* LFN support functions */
  343. #if FF_USE_LFN >= 1                                             /* Code conversion (defined in unicode.c) */
  344. WCHAR ff_oem2uni (WCHAR oem, WORD cp);  /* OEM code to Unicode conversion */
  345. WCHAR ff_uni2oem (DWORD uni, WORD cp);  /* Unicode to OEM code conversion */
  346. DWORD ff_wtoupper (DWORD uni);                  /* Unicode upper-case conversion */
  347. #endif
  348. #if FF_USE_LFN == 3                                             /* Dynamic memory allocation */
  349. void* ff_memalloc (UINT msize);                 /* Allocate memory block */
  350. void ff_memfree (void* mblock);                 /* Free memory block */
  351. #endif
  352.  
  353. /* Sync functions */
  354. #if FF_FS_REENTRANT
  355. int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj); /* Create a sync object */
  356. int ff_req_grant (FF_SYNC_t sobj);              /* Lock sync object */
  357. void ff_rel_grant (FF_SYNC_t sobj);             /* Unlock sync object */
  358. int ff_del_syncobj (FF_SYNC_t sobj);    /* Delete a sync object */
  359. #endif
  360.  
  361.  
  362.  
  363.  
  364. /*--------------------------------------------------------------*/
  365. /* Flags and offset address                                     */
  366.  
  367.  
  368. /* File access mode and open method flags (3rd argument of f_open) */
  369. #define FA_READ                         0x01
  370. #define FA_WRITE                        0x02
  371. #define FA_OPEN_EXISTING        0x00
  372. #define FA_CREATE_NEW           0x04
  373. #define FA_CREATE_ALWAYS        0x08
  374. #define FA_OPEN_ALWAYS          0x10
  375. #define FA_OPEN_APPEND          0x30
  376.  
  377. /* Fast seek controls (2nd argument of f_lseek) */
  378. #define CREATE_LINKMAP  ((FSIZE_t)0 - 1)
  379.  
  380. /* Format options (2nd argument of f_mkfs) */
  381. #define FM_FAT          0x01
  382. #define FM_FAT32        0x02
  383. #define FM_EXFAT        0x04
  384. #define FM_ANY          0x07
  385. #define FM_SFD          0x08
  386.  
  387. /* Filesystem type (FATFS.fs_type) */
  388. #define FS_FAT12        1
  389. #define FS_FAT16        2
  390. #define FS_FAT32        3
  391. #define FS_EXFAT        4
  392.  
  393. /* File attribute bits for directory entry (FILINFO.fattrib) */
  394. #define AM_RDO  0x01    /* Read only */
  395. #define AM_HID  0x02    /* Hidden */
  396. #define AM_SYS  0x04    /* System */
  397. #define AM_DIR  0x10    /* Directory */
  398. #define AM_ARC  0x20    /* Archive */
  399.  
  400.  
  401. #ifdef __cplusplus
  402. }
  403. #endif
  404.  
  405. #endif /* FF_DEFINED */
  406.