[技术问答] 谁有支持长文件名的ff.c文件,最近玩M451的U盘

ff.c.rar

(38.75 KB, 下载次数: 15)



2016-4-19 20:34 上传
点击文件名下载附件

/*---------------------------------------------------------------------------/

/  FatFs - FAT file system module include R0.12     (C)ChaN, 2016

/----------------------------------------------------------------------------/

/ FatFs module is a free software that opened under license policy of

/ following conditions.

/

/ Copyright (C) 2016, ChaN, all right reserved.

/

/ 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.

/---------------------------------------------------------------------------*/





#ifndef _FATFS

#define _FATFS        88100        /* Revision ID */



#ifdef __cplusplus

extern "C" {

#endif



#include "integer.h"        /* Basic integer types */

#include "ffconf.h"                /* FatFs configuration options */

#if _FATFS != _FFCONF

#error Wrong configuration file (ffconf.h).

#endif







/* Definitions of volume management */



#if _MULTI_PARTITION                /* Multiple partition configuration */

typedef struct {

        BYTE pd;        /* Physical drive number */

        BYTE pt;        /* Partition: 0:Auto detect, 1-4:Forced partition) */

} PARTITION;

extern PARTITION VolToPart[];        /* Volume - Partition resolution table */

#define LD2PD(vol) (VolToPart[vol].pd)        /* Get physical drive number */

#define LD2PT(vol) (VolToPart[vol].pt)        /* Get partition index */



#else                                                        /* Single partition configuration */

#define LD2PD(vol) (BYTE)(vol)        /* Each logical drive is bound to the same physical drive number */

#define LD2PT(vol) 0                        /* Find first valid partition or in SFD */



#endif







/* Type of path name strings on FatFs API */



#if _LFN_UNICODE                        /* Unicode string */

#if _USE_LFN == 0

#error _LFN_UNICODE must be 0 at non-LFN cfg.

#endif

#ifndef _INC_TCHAR

typedef WCHAR TCHAR;

#define _T(x) L ## x

#define _TEXT(x) L ## x

#endif



#else                                                /* ANSI/OEM string */

#ifndef _INC_TCHAR

typedef char TCHAR;

#define _T(x) x

#define _TEXT(x) x

#endif



#endif







/* File system object structure (FATFS) */



typedef struct {

        BYTE        fs_type;                /* File system type (0:N/A) */

        BYTE        drv;                        /* Physical drive number */

        BYTE        n_fats;                        /* Number of FATs (1 or 2) */

        BYTE        wflag;                        /* win[] flag (b0:dirty) */

        BYTE        fsi_flag;                /* FSINFO flags (b7:disabled, b0:dirty) */

        WORD        id;                                /* File system mount ID */

        WORD        n_rootdir;                /* Number of root directory entries (FAT12/16) */

        WORD        csize;                        /* Cluster size [sectors] */

#if _MAX_SS != _MIN_SS

        WORD        ssize;                        /* Sector size (512, 1024, 2048 or 4096) */

#endif

#if _FS_EXFAT

        BYTE*        dirbuf;                        /* Directory entry block scratchpad buffer */

#endif

#if _FS_REENTRANT

        _SYNC_t        sobj;                        /* Identifier of sync object */

#endif

#if !_FS_READONLY

        DWORD        last_clst;                /* Last allocated cluster */

        DWORD        free_clst;                /* Number of free clusters */

#endif

#if _FS_RPATH != 0

        DWORD        cdir;                        /* Current directory start cluster (0:root) */

#if _FS_EXFAT

        DWORD        cdc_scl;                /* Containing directory start cluster (invalid when cdir is 0) */

        DWORD        cdc_size;                /* b31-b8:Size of containing directory, b7-b0: Chain status */

        DWORD        cdc_ofs;                /* Offset in the containing directory (invalid when cdir is 0) */

#endif

#endif

        DWORD        n_fatent;                /* Number of FAT entries (number of clusters + 2) */

        DWORD        fsize;                        /* Size of an FAT [sectors] */

        DWORD        volbase;                /* Volume base sector */

        DWORD        fatbase;                /* FAT base sector */

        DWORD        dirbase;                /* Root directory base sector/cluster */

        DWORD        database;                /* Data base sector */

        DWORD        winsect;                /* Current sector appearing in the win[] */

        BYTE        win[_MAX_SS];        /* Disk access window for Directory, FAT (and file data at tiny cfg) */

} FATFS;







/* Type of file size variables and object identifier */



#if _FS_EXFAT

#if _USE_LFN == 0

#error LFN must be enabled when enable exFAT

#endif

typedef QWORD FSIZE_t;

#else

typedef DWORD FSIZE_t;

#endif







/* Object ID and allocation information (_FDID) */



typedef struct {

        FATFS*        fs;                        /* Pointer to the owner file system object */

        WORD        id;                        /* Owner file system mount ID */

        BYTE        attr;                /* Object attribute */

        BYTE        stat;                /* Object chain status (b1-0: =0:not contiguous, =2:contiguous (no data on FAT), =3:got flagmented, b2:sub-directory stretched) */

        DWORD        sclust;                /* Object start cluster (0:no cluster or root directory) */

        FSIZE_t        objsize;        /* Object size (valid when sclust != 0) */

#if _FS_EXFAT

        DWORD        n_cont;                /* Size of coutiguous part, clusters - 1 (valid when stat == 3) */

        DWORD        c_scl;                /* Containing directory start cluster (valid when sclust != 0) */

        DWORD        c_size;                /* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */

        DWORD        c_ofs;                /* Offset in the containing directory (valid when sclust != 0) */

#endif

#if _FS_LOCK != 0

        UINT        lockid;                /* File lock ID origin from 1 (index of file semaphore table Files[]) */

#endif

} _FDID;







/* File object structure (FIL) */



typedef struct {

        _FDID        obj;                        /* Object identifier */

        BYTE        flag;                        /* File status flags */

        BYTE        err;                        /* Abort flag (error code) */

        FSIZE_t        fptr;                        /* File read/write pointer (Zeroed on file open) */

        DWORD        clust;                        /* Current cluster of fpter (not valid when fprt is 0) */

        DWORD        sect;                        /* Sector number appearing in buf[] (0:invalid) */

#if !_FS_READONLY

        DWORD        dir_sect;                /* Sector number containing the directory entry */

        BYTE*        dir_ptr;                /* Pointer to the directory entry in the win[] */

#endif

#if _USE_FASTSEEK

        DWORD*        cltbl;                        /* Pointer to the cluster link map table (Nulled on file open) */

#endif

#if !_FS_TINY

        BYTE        buf[_MAX_SS];        /* File private data read/write window */

#endif

} FIL;







/* Directory object structure (DIR) */



typedef struct {

        _FDID        obj;                        /* Object identifier */

        DWORD        dptr;                        /* Current read/write offset */

        DWORD        clust;                        /* Current cluster */

        DWORD        sect;                        /* Current sector */

        BYTE*        dir;                        /* Pointer to the directory item in the win[] */

        BYTE*        fn;                                /* Pointer to the SFN (in/out) {body[8],ext[3],status[1]} */

#if _USE_LFN != 0

        DWORD        blk_ofs;                /* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */

        WCHAR*        lfn;                        /* Pointer to the LFN working buffer */

#endif

#if _USE_FIND

        const TCHAR* pat;                /* Pointer to the name matching pattern */

#endif

} DIR;







/* File information structure (FILINFO) */



typedef struct {

        FSIZE_t        fsize;                        /* File size */

        WORD        fdate;                        /* Modified date */

        WORD        ftime;                        /* Modified time */

        BYTE        fattrib;                /* File attribute */

#if _USE_LFN != 0

        TCHAR        altname[13];                        /* Altenative file name */

        TCHAR        fname[_MAX_LFN + 1];        /* Primary file name */

#else

        TCHAR        fname[13];                /* File name */

#endif

} FILINFO;







/* File function return code (FRESULT) */



typedef enum {

        FR_OK = 0,                                /* (0) Succeeded */

        FR_DISK_ERR,                        /* (1) A hard error occurred in the low level disk I/O layer */

        FR_INT_ERR,                                /* (2) Assertion failed */

        FR_NOT_READY,                        /* (3) The physical drive cannot work */

        FR_NO_FILE,                                /* (4) Could not find the file */

        FR_NO_PATH,                                /* (5) Could not find the path */

        FR_INVALID_NAME,                /* (6) The path name format is invalid */

        FR_DENIED,                                /* (7) Access denied due to prohibited access or directory full */

        FR_EXIST,                                /* (8) Access denied due to prohibited access */

        FR_INVALID_OBJECT,                /* (9) The file/directory object is invalid */

        FR_WRITE_PROTECTED,                /* (10) The physical drive is write protected */

        FR_INVALID_DRIVE,                /* (11) The logical drive number is invalid */

        FR_NOT_ENABLED,                        /* (12) The volume has no work area */

        FR_NO_FILESYSTEM,                /* (13) There is no valid FAT volume */

        FR_MKFS_ABORTED,                /* (14) The f_mkfs() aborted due to any parameter error */

        FR_TIMEOUT,                                /* (15) Could not get a grant to access the volume within defined period */

        FR_LOCKED,                                /* (16) The operation is rejected according to the file sharing policy */

        FR_NOT_ENOUGH_CORE,                /* (17) LFN working buffer could not be allocated */

        FR_TOO_MANY_OPEN_FILES,        /* (18) Number of open files > _FS_LOCK */

        FR_INVALID_PARAMETER        /* (19) Given parameter is invalid */

} FRESULT;







/*--------------------------------------------------------------*/

/* FatFs module application interface                           */



FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);                                /* Open or create a file */

FRESULT f_close (FIL* fp);                                                                                        /* Close an open file object */

FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);                        /* Read data from a file */

FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);        /* Write data to a file */

FRESULT f_lseek (FIL* fp, FSIZE_t ofs);                                                                /* Move file pointer of a file object */

FRESULT f_truncate (FIL* fp);                                                                                /* Truncate file */

FRESULT f_sync (FIL* fp);                                                                                        /* Flush cached data of a writing file */

FRESULT f_opendir (DIR* dp, const TCHAR* path);                                                /* Open a directory */

FRESULT f_closedir (DIR* dp);                                                                                /* Close an open directory */

FRESULT f_readdir (DIR* dp, FILINFO* fno);                                                        /* Read a directory item */

FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);        /* Find first file */

FRESULT f_findnext (DIR* dp, FILINFO* fno);                                                        /* Find next file */

FRESULT f_mkdir (const TCHAR* path);                                                                /* Create a sub directory */

FRESULT f_unlink (const TCHAR* path);                                                                /* Delete an existing file or directory */

FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);        /* Rename/Move a file or directory */

FRESULT f_stat (const TCHAR* path, FILINFO* fno);                                        /* Get file status */

FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);                        /* Change attribute of the file/dir */

FRESULT f_utime (const TCHAR* path, const FILINFO* fno);                        /* Change timestamp of the file/dir */

FRESULT f_chdir (const TCHAR* path);                                                                /* Change current directory */

FRESULT f_chdrive (const TCHAR* path);                                                                /* Change current drive */

FRESULT f_getcwd (TCHAR* buff, UINT len);                                                        /* Get current directory */

FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);        /* Get number of free clusters on the drive */

FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);        /* Get volume label */

FRESULT f_setlabel (const TCHAR* label);                                                        /* Set volume label */

FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);        /* Forward data to the stream */

FRESULT f_expand (FIL* fp, FSIZE_t szf, BYTE opt);                                        /* Allocate a contiguous block to the file */

FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);                        /* Mount/Unmount a logical drive */

FRESULT f_mkfs (const TCHAR* path, BYTE sfd, UINT au);                                /* Create a file system on the volume */

FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work);                        /* Divide a physical drive into some partitions */

int f_putc (TCHAR c, FIL* fp);                                                                                /* Put a character to the file */

int f_puts (const TCHAR* str, FIL* cp);                                                                /* Put a string to the file */

int f_printf (FIL* fp, const TCHAR* str, ...);                                                /* Put a formatted string to the file */

TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);                                                /* Get a string from the file */



#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))

#define f_error(fp) ((fp)->err)

#define f_tell(fp) ((fp)->fptr)

#define f_size(fp) ((fp)->obj.objsize)

#define f_rewind(fp) f_lseek((fp), 0)

#define f_rewinddir(dp) f_readdir((dp), 0)



#ifndef EOF

#define EOF (-1)

#endif









/*--------------------------------------------------------------*/

/* Additional user defined functions                            */



/* RTC function */

#if !_FS_READONLY && !_FS_NORTC

DWORD get_fattime (void);

#endif



/* Unicode support functions */

#if _USE_LFN != 0                                                /* Unicode - OEM code conversion */

WCHAR ff_convert (WCHAR chr, UINT dir);        /* OEM-Unicode bidirectional conversion */

WCHAR ff_wtoupper (WCHAR chr);                        /* Unicode upper-case conversion */

#if _USE_LFN == 3                                                /* Memory functions */

void* ff_memalloc (UINT msize);                        /* Allocate memory block */

void ff_memfree (void* mblock);                        /* Free memory block */

#endif

#endif



/* Sync functions */

#if _FS_REENTRANT

int ff_cre_syncobj (BYTE vol, _SYNC_t* sobj);        /* Create a sync object */

int ff_req_grant (_SYNC_t sobj);                                /* Lock sync object */

void ff_rel_grant (_SYNC_t sobj);                                /* Unlock sync object */

int ff_del_syncobj (_SYNC_t sobj);                                /* Delete a sync object */

#endif









/*--------------------------------------------------------------*/

/* Flags and offset address                                     */





/* File access control and file status flags (FIL.flag) */



#define        FA_READ                                0x01

#define        FA_WRITE                        0x02

#define        FA_OPEN_EXISTING        0x00

#define        FA_CREATE_NEW                0x04

#define        FA_CREATE_ALWAYS        0x08

#define        FA_OPEN_ALWAYS                0x10

#define _FA_MODIFIED                0x20

#define _FA_DIRTY                        0x40





/* FAT sub type (FATFS.fs_type) */



#define FS_FAT12        1

#define FS_FAT16        2

#define FS_FAT32        3

#define FS_EXFAT        4





/* File attribute bits for directory entry */



#define        AM_RDO        0x01        /* Read only */

#define        AM_HID        0x02        /* Hidden */

#define        AM_SYS        0x04        /* System */

#define        AM_VOL        0x08        /* Volume label */

#define AM_LFN        0x0F        /* LFN entry */

#define AM_DIR        0x10        /* Directory */

#define AM_ARC        0x20        /* Archive */

#define AM_MASK        0x3F        /* Mask of defined bits */





/* Fast seek controls */

#define CREATE_LINKMAP        ((FSIZE_t)0 - 1)





#ifdef __cplusplus

}

#endif



#endif /* _FATFS */

/*-----------------------------------------------------------------------*/

/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2016        */

/*-----------------------------------------------------------------------*/

/* If a working storage control module is available, it should be        */

/* attached to the FatFs via a glue function rather than modifying it.   */

/* This is an example of glue functions to attach various exsisting      */

/* storage control modules to the FatFs module with a defined API.       */

/*-----------------------------------------------------------------------*/



#include "diskio.h"                /* FatFs lower layer API */

#include "usbdisk.h"        /* Example: Header file of existing USB MSD control module */

#include "atadrive.h"        /* Example: Header file of existing ATA harddisk control module */

#include "sdcard.h"                /* Example: Header file of existing MMC/SDC contorl module */



/* Definitions of physical drive number for each drive */

#define ATA                0        /* Example: Map ATA harddisk to physical drive 0 */

#define MMC                1        /* Example: Map MMC/SD card to physical drive 1 */

#define USB                2        /* Example: Map USB MSD to physical drive 2 */





/*-----------------------------------------------------------------------*/

/* Get Drive Status                                                      */

/*-----------------------------------------------------------------------*/



DSTATUS disk_status (

        BYTE pdrv                /* Physical drive nmuber to identify the drive */

)

{

        DSTATUS stat;

        int result;



        switch (pdrv) {

        case ATA :

                result = ATA_disk_status();



                // translate the reslut code here



                return stat;



        case MMC :

                result = MMC_disk_status();



                // translate the reslut code here



                return stat;



        case USB :

                result = USB_disk_status();



                // translate the reslut code here



                return stat;

        }

        return STA_NOINIT;

}







/*-----------------------------------------------------------------------*/

/* Inidialize a Drive                                                    */

/*-----------------------------------------------------------------------*/



DSTATUS disk_initialize (

        BYTE pdrv                                /* Physical drive nmuber to identify the drive */

)

{

        DSTATUS stat;

        int result;



        switch (pdrv) {

        case ATA :

                result = ATA_disk_initialize();



                // translate the reslut code here



                return stat;



        case MMC :

                result = MMC_disk_initialize();



                // translate the reslut code here



                return stat;



        case USB :

                result = USB_disk_initialize();



                // translate the reslut code here



                return stat;

        }

        return STA_NOINIT;

}







/*-----------------------------------------------------------------------*/

/* Read Sector(s)                                                        */

/*-----------------------------------------------------------------------*/



DRESULT disk_read (

        BYTE pdrv,                /* Physical drive nmuber to identify the drive */

        BYTE *buff,                /* Data buffer to store read data */

        DWORD sector,        /* Sector address in LBA */

        UINT count                /* Number of sectors to read */

)

{

        DRESULT res;

        int result;



        switch (pdrv) {

        case ATA :

                // translate the arguments here



                result = ATA_disk_read(buff, sector, count);



                // translate the reslut code here



                return res;



        case MMC :

                // translate the arguments here



                result = MMC_disk_read(buff, sector, count);



                // translate the reslut code here



                return res;



        case USB :

                // translate the arguments here



                result = USB_disk_read(buff, sector, count);



                // translate the reslut code here



                return res;

        }



        return RES_PARERR;

}







/*-----------------------------------------------------------------------*/

/* Write Sector(s)                                                       */

/*-----------------------------------------------------------------------*/



DRESULT disk_write (

        BYTE pdrv,                        /* Physical drive nmuber to identify the drive */

        const BYTE *buff,        /* Data to be written */

        DWORD sector,                /* Sector address in LBA */

        UINT count                        /* Number of sectors to write */

)

{

        DRESULT res;

        int result;



        switch (pdrv) {

        case ATA :

                // translate the arguments here



                result = ATA_disk_write(buff, sector, count);



                // translate the reslut code here



                return res;



        case MMC :

                // translate the arguments here



                result = MMC_disk_write(buff, sector, count);



                // translate the reslut code here



                return res;



        case USB :

                // translate the arguments here



                result = USB_disk_write(buff, sector, count);



                // translate the reslut code here



                return res;

        }



        return RES_PARERR;

}







/*-----------------------------------------------------------------------*/

/* Miscellaneous Functions                                               */

/*-----------------------------------------------------------------------*/



DRESULT disk_ioctl (

        BYTE pdrv,                /* Physical drive nmuber (0..) */

        BYTE cmd,                /* Control code */

        void *buff                /* Buffer to send/receive control data */

)

{

        DRESULT res;

        int result;



        switch (pdrv) {

        case ATA :



                // Process of the command for the ATA drive



                return res;



        case MMC :



                // Process of the command for the MMC/SD card



                return res;



        case USB :



                // Process of the command the USB drive



                return res;

        }



        return RES_PARERR;

}

/*---------------------------------------------------------------------------/

/  FatFs - FAT file system module configuration file  R0.12  (C)ChaN, 2016

/---------------------------------------------------------------------------*/



#define _FFCONF 88100        /* Revision ID */



/*---------------------------------------------------------------------------/

/ Function Configurations

/---------------------------------------------------------------------------*/



#define _FS_READONLY        0

/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)

/  Read-only configuration removes writing API functions, f_write(), f_sync(),

/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()

/  and optional writing functions as well. */





#define _FS_MINIMIZE        0

/* This option defines minimization level to remove some basic API functions.

/

/   0: All basic functions are enabled.

/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()

/      are removed.

/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.

/   3: f_lseek() function is removed in addition to 2. */





#define        _USE_STRFUNC        0

/* This option switches string functions, f_gets(), f_putc(), f_puts() and

/  f_printf().

/

/  0: Disable string functions.

/  1: Enable without LF-CRLF conversion.

/  2: Enable with LF-CRLF conversion. */





#define _USE_FIND                0

/* This option switches filtered directory read functions, f_findfirst() and

/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */





#define        _USE_MKFS                0

/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */





#define        _USE_FASTSEEK        0

/* This option switches fast seek function. (0:Disable or 1:Enable) */





#define        _USE_EXPAND                0

/* This option switches f_expand function. (0:Disable or 1:Enable) */





#define _USE_CHMOD                0

/* This option switches attribute manipulation functions, f_chmod() and f_utime().

/  (0:Disable or 1:Enable) Also _FS_READONLY needs to be 0 to enable this option. */





#define _USE_LABEL                0

/* This option switches volume label functions, f_getlabel() and f_setlabel().

/  (0:Disable or 1:Enable) */





#define        _USE_FORWARD        0

/* This option switches f_forward() function. (0:Disable or 1:Enable)

/  To enable it, also _FS_TINY need to be 1. */





/*---------------------------------------------------------------------------/

/ Locale and Namespace Configurations

/---------------------------------------------------------------------------*/



#define _CODE_PAGE        932

/* This option specifies the OEM code page to be used on the target system.

/  Incorrect setting of the code page can cause a file open failure.

/

/   1   - ASCII (No extended character. Non-LFN cfg. only)

/   437 - U.S.

/   720 - Arabic

/   737 - Greek

/   771 - KBL

/   775 - Baltic

/   850 - Latin 1

/   852 - Latin 2

/   855 - Cyrillic

/   857 - Turkish

/   860 - Portuguese

/   861 - Icelandic

/   862 - Hebrew

/   863 - Canadian French

/   864 - Arabic

/   865 - Nordic

/   866 - Russian

/   869 - Greek 2

/   932 - Japanese (DBCS)

/   936 - Simplified Chinese (DBCS)

/   949 - Korean (DBCS)

/   950 - Traditional Chinese (DBCS)

*/





#define        _USE_LFN        0

#define        _MAX_LFN        255

/* The _USE_LFN switches the support of long file name (LFN).

/

/   0: Disable support of LFN. _MAX_LFN has no effect.

/   1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.

/   2: Enable LFN with dynamic working buffer on the STACK.

/   3: Enable LFN with dynamic working buffer on the HEAP.

/

/  To enable the LFN, Unicode handling functions (option/unicode.c) must be added

/  to the project. The working buffer occupies (_MAX_LFN + 1) * 2 bytes and

/  additional 608 bytes at exFAT enabled. _MAX_LFN can be in range from 12 to 255.

/  It should be set 255 to support full featured LFN operations.

/  When use stack for the working buffer, take care on stack overflow. When use heap

/  memory for the working buffer, memory management functions, ff_memalloc() and

/  ff_memfree(), must be added to the project. */





#define        _LFN_UNICODE        0

/* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)

/  To use Unicode string for the path name, enable LFN and set _LFN_UNICODE = 1.

/  This option also affects behavior of string I/O functions. */





#define _STRF_ENCODE        3

/* When _LFN_UNICODE == 1, this option selects the character encoding on the file to

/  be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().

/

/  0: ANSI/OEM

/  1: UTF-16LE

/  2: UTF-16BE

/  3: UTF-8

/

/  This option has no effect when _LFN_UNICODE == 0. */





#define _FS_RPATH        0

/* This option configures support of relative path.

/

/   0: Disable relative path and remove related functions.

/   1: Enable relative path. f_chdir() and f_chdrive() are available.

/   2: f_getcwd() function is available in addition to 1.

*/





/*---------------------------------------------------------------------------/

/ Drive/Volume Configurations

/---------------------------------------------------------------------------*/



#define _VOLUMES        1

/* Number of volumes (logical drives) to be used. */





#define _STR_VOLUME_ID        0

#define _VOLUME_STRS        "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"

/* _STR_VOLUME_ID switches string support of volume ID.

/  When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive

/  number in the path name. _VOLUME_STRS defines the drive ID strings for each

/  logical drives. Number of items must be equal to _VOLUMES. Valid characters for

/  the drive ID strings are: A-Z and 0-9. */





#define        _MULTI_PARTITION        0

/* This option switches support of multi-partition on a physical drive.

/  By default (0), each logical drive number is bound to the same physical drive

/  number and only an FAT volume found on the physical drive will be mounted.

/  When multi-partition is enabled (1), each logical drive number can be bound to

/  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()

/  funciton will be available. */





#define        _MIN_SS                512

#define        _MAX_SS                512

/* These options configure the range of sector size to be supported. (512, 1024,

/  2048 or 4096) Always set both 512 for most systems, all type of memory cards and

/  harddisk. But a larger value may be required for on-board flash memory and some

/  type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured

/  to variable sector size and GET_SECTOR_SIZE command must be implemented to the

/  disk_ioctl() function. */





#define        _USE_TRIM        0

/* This option switches support of ATA-TRIM. (0:Disable or 1:Enable)

/  To enable Trim function, also CTRL_TRIM command should be implemented to the

/  disk_ioctl() function. */





#define _FS_NOFSINFO        0

/* If you need to know correct free space on the FAT32 volume, set bit 0 of this

/  option, and f_getfree() function at first time after volume mount will force

/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.

/

/  bit0=0: Use free cluster count in the FSINFO if available.

/  bit0=1: Do not trust free cluster count in the FSINFO.

/  bit1=0: Use last allocated cluster number in the FSINFO if available.

/  bit1=1: Do not trust last allocated cluster number in the FSINFO.

*/







/*---------------------------------------------------------------------------/

/ System Configurations

/---------------------------------------------------------------------------*/



#define        _FS_TINY        0

/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)

/  At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS bytes.

/  Instead of private sector buffer eliminated from the file object, common sector

/  buffer in the file system object (FATFS) is used for the file data transfer. */





#define _FS_EXFAT        0

/* This option switches support of exFAT file system in addition to the traditional

/  FAT file system. (0:Disable or 1:Enable) To enable exFAT, also LFN must be enabled.

/  Note that enabling exFAT discards C89 compatibility. */





#define _FS_NORTC        0

#define _NORTC_MON        3

#define _NORTC_MDAY        1

#define _NORTC_YEAR        2016

/* The option _FS_NORTC switches timestamp functiton. If the system does not have

/  any RTC function or valid timestamp is not needed, set _FS_NORTC = 1 to disable

/  the timestamp function. All objects modified by FatFs will have a fixed timestamp

/  defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR in local time.

/  To enable timestamp function (_FS_NORTC = 0), get_fattime() function need to be

/  added to the project to get current time form real-time clock. _NORTC_MON,

/  _NORTC_MDAY and _NORTC_YEAR have no effect. 

/  These options have no effect at read-only configuration (_FS_READONLY = 1). */





#define        _FS_LOCK        0

/* The option _FS_LOCK switches file lock function to control duplicated file open

/  and illegal operation to open objects. This option must be 0 when _FS_READONLY

/  is 1.

/

/  0:  Disable file lock function. To avoid volume corruption, application program

/      should avoid illegal open, remove and rename to the open objects.

/  >0: Enable file lock function. The value defines how many files/sub-directories

/      can be opened simultaneously under file lock control. Note that the file

/      lock control is independent of re-entrancy. */





#define _FS_REENTRANT        0

#define _FS_TIMEOUT                1000

#define        _SYNC_t                        HANDLE

/* The option _FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs

/  module itself. Note that regardless of this option, file access to different

/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()

/  and f_fdisk() function, are always not re-entrant. Only file/directory access

/  to the same volume is under control of this function.

/

/   0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.

/   1: Enable re-entrancy. Also user provided synchronization handlers,

/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()

/      function, must be added to the project. Samples are available in

/      option/syscall.c.

/

/  The _FS_TIMEOUT defines timeout period in unit of time tick.

/  The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,

/  SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be

/  included somewhere in the scope of ff.c. */





/*--- End of configuration options ---*/

/*-------------------------------------------*/

/* Integer type definitions for FatFs module */

/*-------------------------------------------*/



#ifndef _FF_INTEGER

#define _FF_INTEGER



#ifdef _WIN32        /* FatFs development platform */



#include <windows.h>

#include <tchar.h>

typedef unsigned __int64 QWORD;





#else                        /* Embedded platform */



/* These types MUST be 16-bit or 32-bit */

typedef int                                INT;

typedef unsigned int        UINT;



/* This type MUST be 8-bit */

typedef unsigned char        BYTE;



/* These types MUST be 16-bit */

typedef short                        SHORT;

typedef unsigned short        WORD;

typedef unsigned short        WCHAR;



/* These types MUST be 32-bit */

typedef long                        LONG;

typedef unsigned long        DWORD;



/* This type MUST be 64-bit (Remove this for C89 compatibility) */

typedef unsigned long long QWORD;



#endif



#endif