#include <string.h>

#include "ff.h" /* Declarations of FatFs API */

#include "diskio.h" /* Declarations of device I/O functions */

#define DIR FF_DIR

#if FF_DEFINED != 86604 /* Revision ID */

#error Wrong include file (ff.h).

#define MAX_DIR 0x200000 /* Max size of FAT directory */

#define MAX_DIR_EX 0x10000000 /* Max size of exFAT directory */

#define MAX_FAT12 0xFF5 /* Max FAT12 clusters (differs from specs, but right for real DOS/Windows behavior) */

#define MAX_FAT16 0xFFF5 /* Max FAT16 clusters (differs from specs, but right for real DOS/Windows behavior) */

#define MAX_FAT32 0x0FFFFFF5 /* Max FAT32 clusters (not specified, practical limit) */

#define MAX_EXFAT 0x7FFFFFFD /* Max exFAT clusters (differs from specs, implementation limit) */

#define IsUpper(c) ((c) >= 'A' && (c) <= 'Z')

#define IsLower(c) ((c) >= 'a' && (c) <= 'z')

#define IsDigit(c) ((c) >= '0' && (c) <= '9')

#define IsSurrogate(c) ((c) >= 0xD800 && (c) <= 0xDFFF)

#define IsSurrogateH(c) ((c) >= 0xD800 && (c) <= 0xDBFF)

#define IsSurrogateL(c) ((c) >= 0xDC00 && (c) <= 0xDFFF)

#define FA_SEEKEND 0x20 /* Seek to end of the file on file open */

#define FA_MODIFIED 0x40 /* File has been modified */

#define FA_DIRTY 0x80 /* FIL.buf[] needs to be written-back */

#define AM_VOL 0x08 /* Volume label */

#define AM_LFN 0x0F /* LFN entry */

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

#define NSFLAG 11 /* Index of the name status byte */

#define NS_LOSS 0x01 /* Out of 8.3 format */

#define NS_LFN 0x02 /* Force to create LFN entry */

#define NS_LAST 0x04 /* Last segment */

#define NS_BODY 0x08 /* Lower case flag (body) */

#define NS_EXT 0x10 /* Lower case flag (ext) */

#define NS_DOT 0x20 /* Dot entry */

#define NS_NOLFN 0x40 /* Do not find LFN */

#define NS_NONAME 0x80 /* Not followed */

#define ET_BITMAP 0x81 /* Allocation bitmap */

#define ET_UPCASE 0x82 /* Up-case table */

#define ET_VLABEL 0x83 /* Volume label */

#define ET_FILEDIR 0x85 /* File and directory */

#define ET_STREAM 0xC0 /* Stream extension */

#define ET_FILENAME 0xC1 /* Name extension */

#define BS_JmpBoot 0 /* x86 jump instruction (3-byte) */

#define BS_OEMName 3 /* OEM name (8-byte) */

#define BPB_BytsPerSec 11 /* Sector size [byte] (WORD) */

#define BPB_SecPerClus 13 /* Cluster size [sector] (BYTE) */

#define BPB_RsvdSecCnt 14 /* Size of reserved area [sector] (WORD) */

#define BPB_NumFATs 16 /* Number of FATs (BYTE) */

#define BPB_RootEntCnt 17 /* Size of root directory area for FAT [entry] (WORD) */

#define BPB_TotSec16 19 /* Volume size (16-bit) [sector] (WORD) */

#define BPB_Media 21 /* Media descriptor byte (BYTE) */

#define BPB_FATSz16 22 /* FAT size (16-bit) [sector] (WORD) */

#define BPB_SecPerTrk 24 /* Number of sectors per track for int13h [sector] (WORD) */

#define BPB_NumHeads 26 /* Number of heads for int13h (WORD) */

#define BPB_HiddSec 28 /* Volume offset from top of the drive (DWORD) */

#define BPB_TotSec32 32 /* Volume size (32-bit) [sector] (DWORD) */

#define BS_DrvNum 36 /* Physical drive number for int13h (BYTE) */

#define BS_NTres 37 /* WindowsNT error flag (BYTE) */

#define BS_BootSig 38 /* Extended boot signature (BYTE) */

#define BS_VolID 39 /* Volume serial number (DWORD) */

#define BS_VolLab 43 /* Volume label string (8-byte) */

#define BS_FilSysType 54 /* Filesystem type string (8-byte) */

#define BS_BootCode 62 /* Boot code (448-byte) */

#define BS_55AA 510 /* Signature word (WORD) */

#define BPB_FATSz32 36 /* FAT32: FAT size [sector] (DWORD) */

#define BPB_ExtFlags32 40 /* FAT32: Extended flags (WORD) */

#define BPB_FSVer32 42 /* FAT32: Filesystem version (WORD) */

#define BPB_RootClus32 44 /* FAT32: Root directory cluster (DWORD) */

#define BPB_FSInfo32 48 /* FAT32: Offset of FSINFO sector (WORD) */

#define BPB_BkBootSec32 50 /* FAT32: Offset of backup boot sector (WORD) */

#define BS_DrvNum32 64 /* FAT32: Physical drive number for int13h (BYTE) */

#define BS_NTres32 65 /* FAT32: Error flag (BYTE) */

#define BS_BootSig32 66 /* FAT32: Extended boot signature (BYTE) */

#define BS_VolID32 67 /* FAT32: Volume serial number (DWORD) */

#define BS_VolLab32 71 /* FAT32: Volume label string (8-byte) */

#define BS_FilSysType32 82 /* FAT32: Filesystem type string (8-byte) */

#define BS_BootCode32 90 /* FAT32: Boot code (420-byte) */

#define BPB_ZeroedEx 11 /* exFAT: MBZ field (53-byte) */

#define BPB_VolOfsEx 64 /* exFAT: Volume offset from top of the drive [sector] (QWORD) */

#define BPB_TotSecEx 72 /* exFAT: Volume size [sector] (QWORD) */

#define BPB_FatOfsEx 80 /* exFAT: FAT offset from top of the volume [sector] (DWORD) */

#define BPB_FatSzEx 84 /* exFAT: FAT size [sector] (DWORD) */

#define BPB_DataOfsEx 88 /* exFAT: Data offset from top of the volume [sector] (DWORD) */

#define BPB_NumClusEx 92 /* exFAT: Number of clusters (DWORD) */

#define BPB_RootClusEx 96 /* exFAT: Root directory start cluster (DWORD) */

#define BPB_VolIDEx 100 /* exFAT: Volume serial number (DWORD) */

#define BPB_FSVerEx 104 /* exFAT: Filesystem version (WORD) */

#define BPB_VolFlagEx 106 /* exFAT: Volume flags (WORD) */

#define BPB_BytsPerSecEx 108 /* exFAT: Log2 of sector size in unit of byte (BYTE) */

#define BPB_SecPerClusEx 109 /* exFAT: Log2 of cluster size in unit of sector (BYTE) */

#define BPB_NumFATsEx 110 /* exFAT: Number of FATs (BYTE) */

#define BPB_DrvNumEx 111 /* exFAT: Physical drive number for int13h (BYTE) */

#define BPB_PercInUseEx 112 /* exFAT: Percent in use (BYTE) */

#define BPB_RsvdEx 113 /* exFAT: Reserved (7-byte) */

#define BS_BootCodeEx 120 /* exFAT: Boot code (390-byte) */

#define DIR_Name 0 /* Short file name (11-byte) */

#define DIR_Attr 11 /* Attribute (BYTE) */

#define DIR_NTres 12 /* Lower case flag (BYTE) */

#define DIR_CrtTime10 13 /* Created time sub-second (BYTE) */

#define DIR_CrtTime 14 /* Created time (DWORD) */

#define DIR_LstAccDate 18 /* Last accessed date (WORD) */

#define DIR_FstClusHI 20 /* Higher 16-bit of first cluster (WORD) */

#define DIR_ModTime 22 /* Modified time (DWORD) */

#define DIR_FstClusLO 26 /* Lower 16-bit of first cluster (WORD) */

#define DIR_FileSize 28 /* File size (DWORD) */

#define LDIR_Ord 0 /* LFN: LFN order and LLE flag (BYTE) */

#define LDIR_Attr 11 /* LFN: LFN attribute (BYTE) */

#define LDIR_Type 12 /* LFN: Entry type (BYTE) */

#define LDIR_Chksum 13 /* LFN: Checksum of the SFN (BYTE) */

#define LDIR_FstClusLO 26 /* LFN: MBZ field (WORD) */

#define XDIR_Type 0 /* exFAT: Type of exFAT directory entry (BYTE) */

#define XDIR_NumLabel 1 /* exFAT: Number of volume label characters (BYTE) */

#define XDIR_Label 2 /* exFAT: Volume label (11-WORD) */

#define XDIR_CaseSum 4 /* exFAT: Sum of case conversion table (DWORD) */

#define XDIR_NumSec 1 /* exFAT: Number of secondary entries (BYTE) */

#define XDIR_SetSum 2 /* exFAT: Sum of the set of directory entries (WORD) */

#define XDIR_Attr 4 /* exFAT: File attribute (WORD) */

#define XDIR_CrtTime 8 /* exFAT: Created time (DWORD) */

#define XDIR_ModTime 12 /* exFAT: Modified time (DWORD) */

#define XDIR_AccTime 16 /* exFAT: Last accessed time (DWORD) */

#define XDIR_CrtTime10 20 /* exFAT: Created time subsecond (BYTE) */

#define XDIR_ModTime10 21 /* exFAT: Modified time subsecond (BYTE) */

#define XDIR_CrtTZ 22 /* exFAT: Created timezone (BYTE) */

#define XDIR_ModTZ 23 /* exFAT: Modified timezone (BYTE) */

#define XDIR_AccTZ 24 /* exFAT: Last accessed timezone (BYTE) */

#define XDIR_GenFlags 33 /* exFAT: General secondary flags (BYTE) */

#define XDIR_NumName 35 /* exFAT: Number of file name characters (BYTE) */

#define XDIR_NameHash 36 /* exFAT: Hash of file name (WORD) */

#define XDIR_ValidFileSize 40 /* exFAT: Valid file size (QWORD) */

#define XDIR_FstClus 52 /* exFAT: First cluster of the file data (DWORD) */

#define XDIR_FileSize 56 /* exFAT: File/Directory size (QWORD) */

#define SZDIRE 32 /* Size of a directory entry */

#define DDEM 0xE5 /* Deleted directory entry mark set to DIR_Name[0] */

#define RDDEM 0x05 /* Replacement of the character collides with DDEM */

#define LLEF 0x40 /* Last long entry flag in LDIR_Ord */

#define FSI_LeadSig 0 /* FAT32 FSI: Leading signature (DWORD) */

#define FSI_StrucSig 484 /* FAT32 FSI: Structure signature (DWORD) */

#define FSI_Free_Count 488 /* FAT32 FSI: Number of free clusters (DWORD) */

#define FSI_Nxt_Free 492 /* FAT32 FSI: Last allocated cluster (DWORD) */

#define MBR_Table 446 /* MBR: Offset of partition table in the MBR */

#define SZ_PTE 16 /* MBR: Size of a partition table entry */

#define PTE_Boot 0 /* MBR PTE: Boot indicator */

#define PTE_StHead 1 /* MBR PTE: Start head */

#define PTE_StSec 2 /* MBR PTE: Start sector */

#define PTE_StCyl 3 /* MBR PTE: Start cylinder */

#define PTE_System 4 /* MBR PTE: System ID */

#define PTE_EdHead 5 /* MBR PTE: End head */

#define PTE_EdSec 6 /* MBR PTE: End sector */

#define PTE_EdCyl 7 /* MBR PTE: End cylinder */

#define PTE_StLba 8 /* MBR PTE: Start in LBA */

#define PTE_SizLba 12 /* MBR PTE: Size in LBA */

#define ABORT(fs, res) { fp->err = (BYTE)(res); LEAVE_FF(fs, res); }

#if FF_FS_REENTRANT

#if FF_USE_LFN == 1

#error Static LFN work area cannot be used at thread-safe configuration

#define LEAVE_FF(fs, res) { unlock_fs(fs, res); return res; }

#define LEAVE_FF(fs, res) return res

#if FF_MULTI_PARTITION

#define LD2PT(fs) (fs->part) /* Get partition index */

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

#if (FF_MAX_SS < FF_MIN_SS) || (FF_MAX_SS != 512 && FF_MAX_SS != 1024 && FF_MAX_SS != 2048 && FF_MAX_SS != 4096) || (FF_MIN_SS != 512 && FF_MIN_SS != 1024 && FF_MIN_SS != 2048 && FF_MIN_SS != 4096)

#error Wrong sector size configuration

#if FF_MAX_SS == FF_MIN_SS

#define SS(fs) ((UINT)FF_MAX_SS) /* Fixed sector size */

#define SS(fs) ((fs)->ssize) /* Variable sector size */

#if FF_FS_NORTC == 1

#if FF_NORTC_YEAR < 1980 || FF_NORTC_YEAR > 2107 || FF_NORTC_MON < 1 || FF_NORTC_MON > 12 || FF_NORTC_MDAY < 1 || FF_NORTC_MDAY > 31

#error Invalid FF_FS_NORTC settings

#define GET_FATTIME() ((DWORD)(FF_NORTC_YEAR - 1980) << 25 | (DWORD)FF_NORTC_MON << 21 | (DWORD)FF_NORTC_MDAY << 16)

#define GET_FATTIME() get_fattime()

#if FF_FS_MAKE_VOLID == 1

#define MAKE_VOLID(x) (make_volid())

#define MAKE_VOLID(x) (GET_FATTIME())

#if FF_FS_LOCK != 0

#if FF_FS_READONLY

#error FF_FS_LOCK must be 0 at read-only configuration

typedef struct {

FATFS *fs; /* Object ID 1, volume (NULL:blank entry) */

DWORD clu; /* Object ID 2, containing directory (0:root) */

DWORD ofs; /* Object ID 3, offset in the directory */

WORD ctr; /* Object open counter, 0:none, 0x01..0xFF:read mode open count, 0x100:write mode */

} FILESEM;

#if FF_CODE_PAGE == 437

#define TBL_CT437 {0x80,0x9A,0x45,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \

0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0x41,0x49,0x4F,0x55,0xA5}

#define TBL_CT437 {0x80,0x9A,0x45,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \

#define TBL_CT720 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_CT737 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_CT771 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_CT775 {0x80,0x9A,0x91,0xA0,0x8E,0x95,0x8F,0x80,0xAD,0xED,0x8A,0x8A,0xA1,0x8D,0x8E,0x8F, \

#define TBL_CT850 {0x43,0x55,0x45,0x41,0x41,0x41,0x41,0x43,0x45,0x45,0x45,0x49,0x49,0x49,0x41,0x41, \

#define TBL_CT852 {0x80,0x9A,0x90,0xB6,0x8E,0xDE,0x8F,0x80,0x9D,0xD3,0x8A,0x8A,0xD7,0x8D,0x8E,0x8F, \

#define TBL_CT855 {0x81,0x81,0x83,0x83,0x85,0x85,0x87,0x87,0x89,0x89,0x8B,0x8B,0x8D,0x8D,0x8F,0x8F, \

#define TBL_CT857 {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x49,0x8E,0x8F, \

#define TBL_CT860 {0x80,0x9A,0x90,0x8F,0x8E,0x91,0x86,0x80,0x89,0x89,0x92,0x8B,0x8C,0x98,0x8E,0x8F, \

#define TBL_CT861 {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x8B,0x8B,0x8D,0x8E,0x8F, \

#define TBL_CT862 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_CT863 {0x43,0x55,0x45,0x41,0x41,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x41,0x8F, \

#define TBL_CT864 {0x80,0x9A,0x45,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \

#define TBL_CT865 {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \

#define TBL_CT866 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_CT869 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \

#define TBL_DC932 {0x81, 0x9F, 0xE0, 0xFC, 0x40, 0x7E, 0x80, 0xFC, 0x00, 0x00}

#define TBL_DC936 {0x81, 0xFE, 0x00, 0x00, 0x40, 0x7E, 0x80, 0xFE, 0x00, 0x00}

#define TBL_DC949 {0x81, 0xFE, 0x00, 0x00, 0x41, 0x5A, 0x61, 0x7A, 0x81, 0xFE}

#define TBL_DC950 {0x81, 0xFE, 0x00, 0x00, 0x40, 0x7E, 0xA1, 0xFE, 0x00, 0x00}

#define MERGE_2STR(a, b) a ## b

#define MKCVTBL(hd, cp) MERGE_2STR(hd, cp)

#if FF_VOLUMES < 1 || FF_VOLUMES > 10

#error Wrong FF_VOLUMES setting

static WORD Fsid; /* Filesystem mount ID */

#if FF_FS_LOCK != 0

static FILESEM Files[FF_FS_LOCK]; /* Open object lock semaphores */

#if FF_STR_VOLUME_ID

#ifdef FF_VOLUME_STRS

static const char* const VolumeStr[FF_VOLUMES] = {FF_VOLUME_STRS}; /* Pre-defined volume ID */

#if FF_USE_LFN == 0 /* Non-LFN configuration */

#if FF_FS_EXFAT

#error LFN must be enabled when enable exFAT

#define DEF_NAMBUF

#define INIT_NAMBUF(fs)

#define FREE_NAMBUF()

#define LEAVE_MKFS(res) return res

#else /* LFN configurations */

#if FF_MAX_LFN < 12 || FF_MAX_LFN > 255

#error Wrong setting of FF_MAX_LFN

#if FF_LFN_BUF < FF_SFN_BUF || FF_SFN_BUF < 12

#error Wrong setting of FF_LFN_BUF or FF_SFN_BUF

#if FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3

#error Wrong setting of FF_LFN_UNICODE

static const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30}; /* FAT: Offset of LFN characters in the directory entry */

#define MAXDIRB(nc) ((nc + 44U) / 15 * SZDIRE) /* exFAT: Size of directory entry block scratchpad buffer needed for the name length */

#if FF_USE_LFN == 1 /* LFN enabled with static working buffer */

#if FF_FS_EXFAT

static BYTE DirBuf[MAXDIRB(FF_MAX_LFN)]; /* Directory entry block scratchpad buffer */

static WCHAR LfnBuf[FF_MAX_LFN + 1]; /* LFN working buffer */

#define DEF_NAMBUF

#define INIT_NAMBUF(fs)

#define FREE_NAMBUF()

#define LEAVE_MKFS(res) return res

#elif FF_USE_LFN == 2 /* LFN enabled with dynamic working buffer on the stack */

#if FF_FS_EXFAT

#define DEF_NAMBUF WCHAR lbuf[FF_MAX_LFN+1]; BYTE dbuf[MAXDIRB(FF_MAX_LFN)]; /* LFN working buffer and directory entry block scratchpad buffer */

#define INIT_NAMBUF(fs) { (fs)->lfnbuf = lbuf; (fs)->dirbuf = dbuf; }

#define FREE_NAMBUF()

#define DEF_NAMBUF WCHAR lbuf[FF_MAX_LFN+1]; /* LFN working buffer */

#define INIT_NAMBUF(fs) { (fs)->lfnbuf = lbuf; }

#define FREE_NAMBUF()

#define LEAVE_MKFS(res) return res

#elif FF_USE_LFN == 3 /* LFN enabled with dynamic working buffer on the heap */

#if FF_FS_EXFAT

#define DEF_NAMBUF WCHAR *lfn; /* Pointer to LFN working buffer and directory entry block scratchpad buffer */

#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)

#define DEF_NAMBUF WCHAR *lfn; /* Pointer to LFN working buffer */

#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)

#define LEAVE_MKFS(res) { if (!work) ff_memfree(buf); return res; }

#define MAX_MALLOC 0x8000 /* Must be >=FF_MAX_SS */

#error Wrong setting of FF_USE_LFN

#endif /* FF_USE_LFN == 1 */

#endif /* FF_USE_LFN == 0 */

#if FF_CODE_PAGE == 0 /* Run-time code page configuration */

#define CODEPAGE CodePage

static WORD CodePage; /* Current code page */

static const BYTE *ExCvt, *DbcTbl; /* Pointer to current SBCS up-case table and DBCS code range table below */

static const BYTE Ct437[] = TBL_CT437;

static const BYTE Ct720[] = TBL_CT720;

static const BYTE Ct737[] = TBL_CT737;

static const BYTE Ct771[] = TBL_CT771;

static const BYTE Ct775[] = TBL_CT775;

static const BYTE Ct850[] = TBL_CT850;

static const BYTE Ct852[] = TBL_CT852;

static const BYTE Ct855[] = TBL_CT855;

static const BYTE Ct857[] = TBL_CT857;

static const BYTE Ct860[] = TBL_CT860;

static const BYTE Ct861[] = TBL_CT861;

static const BYTE Ct862[] = TBL_CT862;

static const BYTE Ct863[] = TBL_CT863;

static const BYTE Ct864[] = TBL_CT864;

static const BYTE Ct865[] = TBL_CT865;

static const BYTE Ct866[] = TBL_CT866;

static const BYTE Ct869[] = TBL_CT869;

static const BYTE Dc932[] = TBL_DC932;

static const BYTE Dc936[] = TBL_DC936;

static const BYTE Dc949[] = TBL_DC949;

static const BYTE Dc950[] = TBL_DC950;

#elif FF_CODE_PAGE < 900 /* Static code page configuration (SBCS) */

#define CODEPAGE FF_CODE_PAGE

static const BYTE ExCvt[] = MKCVTBL(TBL_CT, FF_CODE_PAGE);

#else /* Static code page configuration (DBCS) */

#define CODEPAGE FF_CODE_PAGE

static const BYTE DbcTbl[] = MKCVTBL(TBL_DC, FF_CODE_PAGE);

static WORD ld_word (const BYTE* ptr) /* Load a 2-byte little-endian word */

{

WORD rv;

rv = ptr[1];

rv = rv << 8 | ptr[0];

return rv;

}

static DWORD ld_dword (const BYTE* ptr) /* Load a 4-byte little-endian word */

{

DWORD rv;

rv = ptr[3];

rv = rv << 8 | ptr[2];

rv = rv << 8 | ptr[1];

rv = rv << 8 | ptr[0];

return rv;

}

#if FF_FS_EXFAT

static QWORD ld_qword (const BYTE* ptr) /* Load an 8-byte little-endian word */

{

QWORD rv;

rv = ptr[7];

rv = rv << 8 | ptr[6];

rv = rv << 8 | ptr[5];

rv = rv << 8 | ptr[4];

rv = rv << 8 | ptr[3];

rv = rv << 8 | ptr[2];

rv = rv << 8 | ptr[1];

rv = rv << 8 | ptr[0];

return rv;

}

#if !FF_FS_READONLY

static void st_word (BYTE* ptr, WORD val) /* Store a 2-byte word in little-endian */

{

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val;

}

static void st_dword (BYTE* ptr, DWORD val) /* Store a 4-byte word in little-endian */

{

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val;

}

#if FF_FS_EXFAT

static void st_qword (BYTE* ptr, QWORD val) /* Store an 8-byte word in little-endian */

{

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val; val >>= 8;

*ptr++ = (BYTE)val;

}

#endif /* !FF_FS_READONLY */

#define mem_cpy memcpy

#define mem_set memset

#define mem_cmp memcmp

static int chk_chr (const char* str, int chr) /* NZ:contained, ZR:not contained */

{

while (*str && *str != chr) str++;

return *str;

}

static int dbc_1st (BYTE c)

{

#if FF_CODE_PAGE == 0 /* Variable code page */

if (DbcTbl && c >= DbcTbl[0]) {

if (c <= DbcTbl[1]) return 1; /* 1st byte range 1 */

if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1; /* 1st byte range 2 */

}

#elif FF_CODE_PAGE >= 900 /* DBCS fixed code page */

if (c >= DbcTbl[0]) {

if (c <= DbcTbl[1]) return 1;

if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1;

}

#else /* SBCS fixed code page */

if (c != 0) return 0; /* Always false */

return 0;

}

static int dbc_2nd (BYTE c)

{

#if FF_CODE_PAGE == 0 /* Variable code page */

if (DbcTbl && c >= DbcTbl[4]) {

if (c <= DbcTbl[5]) return 1; /* 2nd byte range 1 */

if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1; /* 2nd byte range 2 */

if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1; /* 2nd byte range 3 */

}

#elif FF_CODE_PAGE >= 900 /* DBCS fixed code page */

if (c >= DbcTbl[4]) {

if (c <= DbcTbl[5]) return 1;

if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1;

if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1;

}

#else /* SBCS fixed code page */

if (c != 0) return 0; /* Always false */

return 0;

}

#if FF_USE_LFN

static DWORD tchar2uni ( /* Returns character in UTF-16 encoding (>=0x10000 on double encoding unit, 0xFFFFFFFF on decode error) */

const TCHAR** str /* Pointer to pointer to TCHAR string in configured encoding */

)

{

DWORD uc;

const TCHAR *p = *str;

#if FF_LFN_UNICODE == 1 /* UTF-16 input */

WCHAR wc;

uc = *p++; /* Get a unit */

if (IsSurrogate(uc)) { /* Surrogate? */

wc = *p++; /* Get low surrogate */

if (!IsSurrogateH(uc) || !IsSurrogateL(wc)) return 0xFFFFFFFF; /* Wrong surrogate? */

uc = uc << 16 | wc;

}

#elif FF_LFN_UNICODE == 2 /* UTF-8 input */

BYTE b;

int nf;

uc = (BYTE)*p++; /* Get a unit */

if (uc & 0x80) { /* Multiple byte code? */

if ((uc & 0xE0) == 0xC0) { /* 2-byte sequence? */

uc &= 0x1F; nf = 1;

} else {

if ((uc & 0xF0) == 0xE0) { /* 3-byte sequence? */

uc &= 0x0F; nf = 2;

} else {

if ((uc & 0xF8) == 0xF0) { /* 4-byte sequence? */

uc &= 0x07; nf = 3;

} else { /* Wrong sequence */

return 0xFFFFFFFF;

}

}

}

do { /* Get trailing bytes */

b = (BYTE)*p++;

if ((b & 0xC0) != 0x80) return 0xFFFFFFFF; /* Wrong sequence? */

uc = uc << 6 | (b & 0x3F);

} while (--nf != 0);

if (uc < 0x80 || IsSurrogate(uc) || uc >= 0x110000) return 0xFFFFFFFF; /* Wrong code? */

if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF); /* Make a surrogate pair if needed */

}

#elif FF_LFN_UNICODE == 3 /* UTF-32 input */

uc = (TCHAR)*p++; /* Get a unit */

if (uc >= 0x110000) return 0xFFFFFFFF; /* Wrong code? */

if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF); /* Make a surrogate pair if needed */

#else /* ANSI/OEM input */

BYTE b;

WCHAR wc;

wc = (BYTE)*p++; /* Get a byte */

if (dbc_1st((BYTE)wc)) { /* Is it a DBC 1st byte? */

b = (BYTE)*p++; /* Get 2nd byte */

if (!dbc_2nd(b)) return 0xFFFFFFFF; /* Invalid code? */

wc = (wc << 8) + b; /* Make a DBC */

}

if (wc != 0) {

wc = ff_oem2uni(wc, CODEPAGE); /* ANSI/OEM ==> Unicode */

if (wc == 0) return 0xFFFFFFFF; /* Invalid code? */

}

uc = wc;

*str = p; /* Next read pointer */

return uc;

}

static BYTE put_utf ( /* Returns number of encoding units written (0:buffer overflow or wrong encoding) */

)

{

#if FF_LFN_UNICODE == 1 /* UTF-16 output */

WCHAR hs, wc;

hs = (WCHAR)(chr >> 16);

wc = (WCHAR)chr;

if (hs == 0) { /* Single encoding unit? */

if (szb < 1 || IsSurrogate(wc)) return 0; /* Buffer overflow or wrong code? */

*buf = wc;

return 1;

}

if (szb < 2 || !IsSurrogateH(hs) || !IsSurrogateL(wc)) return 0; /* Buffer overflow or wrong surrogate? */

*buf++ = hs;

*buf++ = wc;

return 2;

#elif FF_LFN_UNICODE == 2 /* UTF-8 output */

DWORD hc;

if (chr < 0x80) { /* Single byte code? */

if (szb < 1) return 0; /* Buffer overflow? */

*buf = (TCHAR)chr;

return 1;

}

if (chr < 0x800) { /* 2-byte sequence? */

if (szb < 2) return 0; /* Buffer overflow? */

*buf++ = (TCHAR)(0xC0 | (chr >> 6 & 0x1F));

*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));

return 2;

}

if (chr < 0x10000) { /* 3-byte sequence? */

if (szb < 3 || IsSurrogate(chr)) return 0; /* Buffer overflow or wrong code? */

*buf++ = (TCHAR)(0xE0 | (chr >> 12 & 0x0F));

*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F));

*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));

return 3;

}

/* 4-byte sequence */

if (szb < 4) return 0; /* Buffer overflow? */

hc = ((chr & 0xFFFF0000) - 0xD8000000) >> 6; /* Get high 10 bits */

chr = (chr & 0xFFFF) - 0xDC00; /* Get low 10 bits */

if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */

chr = (hc | chr) + 0x10000;

*buf++ = (TCHAR)(0xF0 | (chr >> 18 & 0x07));

*buf++ = (TCHAR)(0x80 | (chr >> 12 & 0x3F));

*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F));

*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));

return 4;

#elif FF_LFN_UNICODE == 3 /* UTF-32 output */

DWORD hc;

if (szb < 1) return 0; /* Buffer overflow? */

if (chr >= 0x10000) { /* Out of BMP? */

hc = ((chr & 0xFFFF0000) - 0xD8000000) >> 6; /* Get high 10 bits */

chr = (chr & 0xFFFF) - 0xDC00; /* Get low 10 bits */

if (hc >= 0x100000 || chr >= 0x400) return 0; /* Wrong surrogate? */

chr = (hc | chr) + 0x10000;

}

*buf++ = (TCHAR)chr;

return 1;

#else /* ANSI/OEM output */

WCHAR wc;

wc = ff_uni2oem(chr, CODEPAGE);

if (wc >= 0x100) { /* Is this a DBC? */

if (szb < 2) return 0;

*buf++ = (char)(wc >> 8); /* Store DBC 1st byte */

*buf++ = (TCHAR)wc; /* Store DBC 2nd byte */

return 2;

}

if (wc == 0 || szb < 1) return 0; /* Invalid char or buffer overflow? */

*buf++ = (TCHAR)wc; /* Store the character */

return 1;

}

#endif /* FF_USE_LFN */

#if FF_FS_REENTRANT

static int lock_fs ( /* 1:Ok, 0:timeout */

FATFS* fs /* Filesystem object */

)

{

return ff_req_grant(fs->sobj);

}

static void unlock_fs (

FATFS* fs, /* Filesystem object */

FRESULT res /* Result code to be returned */

)

{

if (fs && res != FR_NOT_ENABLED && res != FR_INVALID_DRIVE && res != FR_TIMEOUT) {

ff_rel_grant(fs->sobj);

}

}

#if FF_FS_LOCK != 0

static FRESULT chk_lock ( /* Check if the file can be accessed */

DIR* dp, /* Directory object pointing the file to be checked */

int acc /* Desired access type (0:Read mode open, 1:Write mode open, 2:Delete or rename) */

)

{

UINT i, be;

/* Search open object table for the object */

be = 0;

for (i = 0; i < FF_FS_LOCK; i++) {

if (Files[i].fs) { /* Existing entry */

if (Files[i].fs == dp->obj.fs && /* Check if the object matches with an open object */

Files[i].clu == dp->obj.sclust &&

Files[i].ofs == dp->dptr) break;

} else { /* Blank entry */

be = 1;

}

}

if (i == FF_FS_LOCK) { /* The object has not been opened */

return (!be && acc != 2) ? FR_TOO_MANY_OPEN_FILES : FR_OK; /* Is there a blank entry for new object? */

}

/* The object was opened. Reject any open against writing file and all write mode open */

return (acc != 0 || Files[i].ctr == 0x100) ? FR_LOCKED : FR_OK;

}

static int enq_lock (void) /* Check if an entry is available for a new object */

{

UINT i;

for (i = 0; i < FF_FS_LOCK && Files[i].fs; i++) ;

return (i == FF_FS_LOCK) ? 0 : 1;

}

static UINT inc_lock ( /* Increment object open counter and returns its index (0:Internal error) */

DIR* dp, /* Directory object pointing the file to register or increment */

int acc /* Desired access (0:Read, 1:Write, 2:Delete/Rename) */

)

{

UINT i;

for (i = 0; i < FF_FS_LOCK; i++) { /* Find the object */

if (Files[i].fs == dp->obj.fs &&

Files[i].clu == dp->obj.sclust &&

Files[i].ofs == dp->dptr) break;

}

if (i == FF_FS_LOCK) { /* Not opened. Register it as new. */

for (i = 0; i < FF_FS_LOCK && Files[i].fs; i++) ;

if (i == FF_FS_LOCK) return 0; /* No free entry to register (int err) */

Files[i].fs = dp->obj.fs;

Files[i].clu = dp->obj.sclust;

Files[i].ofs = dp->dptr;

Files[i].ctr = 0;

}

if (acc >= 1 && Files[i].ctr) return 0; /* Access violation (int err) */

Files[i].ctr = acc ? 0x100 : Files[i].ctr + 1; /* Set semaphore value */

return i + 1; /* Index number origin from 1 */

}

static FRESULT dec_lock ( /* Decrement object open counter */

UINT i /* Semaphore index (1..) */

)

{

WORD n;

FRESULT res;

if (--i < FF_FS_LOCK) { /* Index number origin from 0 */

n = Files[i].ctr;

if (n == 0x100) n = 0; /* If write mode open, delete the entry */

if (n > 0) n--; /* Decrement read mode open count */

Files[i].ctr = n;

if (n == 0) Files[i].fs = 0; /* Delete the entry if open count gets zero */

res = FR_OK;

} else {

res = FR_INT_ERR; /* Invalid index nunber */