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

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

/

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

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

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

#include "string.h"

#include "configuration.h"

extern void MMPrintString(char *s);

extern void error(char *msg, ...);

extern const int enableexFAT;

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

Module Private Definitions

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

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

#error Wrong include file (ff.h).

#endif

#define mem_cpy(dst, src, sz) memcpy((dst), (src), (sz))

#define mem_set(dst, src, sz) memset((dst), (src), (sz))

//#define memset(dst, src, sz) memset((dst), (src), (sz))

/* Limits and boundaries */

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

/* Character code support macros */

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

/* Additional file access control and file status flags for internal use */

#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 */

/* Additional file attribute bits for internal use */

#define AM_VOL 0x08 /* Volume label */

#define AM_LFN 0x0F /* LFN entry */

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

/* Name status flags in fn[11] */

#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 */

/* exFAT directory entry types */

#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 */

/* FatFs refers the FAT structure as simple byte array instead of structure member

/ because the C structure is not binary compatible between different platforms */

#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 GPTH_Sign 0 /* GPT: Header signature (8-byte) */

#define GPTH_Rev 8 /* GPT: Revision (DWORD) */

#define GPTH_Size 12 /* GPT: Header size (DWORD) */

#define GPTH_Bcc 16 /* GPT: Header BCC (DWORD) */

#define GPTH_CurLba 24 /* GPT: Main header LBA (QWORD) */

#define GPTH_BakLba 32 /* GPT: Backup header LBA (QWORD) */

#define GPTH_FstLba 40 /* GPT: First LBA for partitions (QWORD) */

#define GPTH_LstLba 48 /* GPT: Last LBA for partitions (QWORD) */

#define GPTH_DskGuid 56 /* GPT: Disk GUID (16-byte) */

#define GPTH_PtOfs 72 /* GPT: Partation table LBA (QWORD) */

#define GPTH_PtNum 80 /* GPT: Number of table entries (DWORD) */

#define GPTH_PteSize 84 /* GPT: Size of table entry (DWORD) */

#define GPTH_PtBcc 88 /* GPT: Partation table BCC (DWORD) */

#define SZ_GPTE 128 /* GPT: Size of partition table entry */

#define GPTE_PtGuid 0 /* GPT PTE: Partition type GUID (16-byte) */

#define GPTE_UpGuid 16 /* GPT PTE: Partition unique GUID (16-byte) */

#define GPTE_FstLba 32 /* GPT PTE: First LBA (QWORD) */

#define GPTE_LstLba 40 /* GPT PTE: Last LBA inclusive (QWORD) */

#define GPTE_Flags 48 /* GPT PTE: Flags (QWORD) */

#define GPTE_Name 56 /* GPT PTE: Name */

/* Post process on fatal error in the file operations */

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

/* Re-entrancy related */

#if FF_FS_REENTRANT

#if FF_USE_LFN == 1

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

#endif

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

#else

#define LEAVE_FF(fs, res) return res

#endif

/* Definitions of logical drive - physical location conversion */

#if FF_MULTI_PARTITION

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

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

#else

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

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

#endif

/* Definitions of sector size */

#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

#endif

#if FF_MAX_SS == FF_MIN_SS

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

#else

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

#endif

/* Timestamp */

#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

#endif

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

#else

#define GET_FATTIME() get_fattime()

#endif

/* File lock controls */

#if FF_FS_LOCK != 0

#if FF_FS_READONLY

#error FF_FS_LOCK must be 0 at read-only configuration

#endif

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;

#endif

/* SBCS up-case tables (\x80-\xFF) */

#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,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x92,0x92,0x93,0x94,0x95,0x96,0x97,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, \

0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0xAA,0x92,0x93,0x94,0x95,0x96, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0x97,0xEA,0xEB,0xEC,0xE4,0xED,0xEE,0xEF,0xF5,0xF0,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

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

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDC,0xDE,0xDE, \

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFE,0xFF}

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

0x90,0x92,0x92,0xE2,0x99,0x95,0x96,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \

0xA0,0xA1,0xE0,0xA3,0xA3,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xA5,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE3,0xE8,0xE8,0xEA,0xEA,0xEE,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x45,0x92,0x92,0x4F,0x4F,0x4F,0x55,0x55,0x59,0x4F,0x55,0x4F,0x9C,0x4F,0x9E,0x9F, \

0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0x41,0x41,0x41,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0x41,0x41,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD1,0xD1,0x45,0x45,0x45,0x49,0x49,0x49,0x49,0xD9,0xDA,0xDB,0xDC,0xDD,0x49,0xDF, \

0x4F,0xE1,0x4F,0x4F,0x4F,0x4F,0xE6,0xE8,0xE8,0x55,0x55,0x55,0x59,0x59,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x91,0xE2,0x99,0x95,0x95,0x97,0x97,0x99,0x9A,0x9B,0x9B,0x9D,0x9E,0xAC, \

0xB5,0xD6,0xE0,0xE9,0xA4,0xA4,0xA6,0xA6,0xA8,0xA8,0xAA,0x8D,0xAC,0xB8,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBD,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC6,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD1,0xD1,0xD2,0xD3,0xD2,0xD5,0xD6,0xD7,0xB7,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE3,0xD5,0xE6,0xE6,0xE8,0xE9,0xE8,0xEB,0xED,0xED,0xDD,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xEB,0xFC,0xFC,0xFE,0xFF}

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

0x91,0x91,0x93,0x93,0x95,0x95,0x97,0x97,0x99,0x99,0x9B,0x9B,0x9D,0x9D,0x9F,0x9F, \

0xA1,0xA1,0xA3,0xA3,0xA5,0xA5,0xA7,0xA7,0xA9,0xA9,0xAB,0xAB,0xAD,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB6,0xB6,0xB8,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD1,0xD1,0xD3,0xD3,0xD5,0xD5,0xD7,0xD7,0xDD,0xD9,0xDA,0xDB,0xDC,0xDD,0xE0,0xDF, \

0xE0,0xE2,0xE2,0xE4,0xE4,0xE6,0xE6,0xE8,0xE8,0xEA,0xEA,0xEC,0xEC,0xEE,0xEE,0xEF, \

0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x98,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9E, \

0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA6,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0x49,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x8C,0x99,0xA9,0x96,0x9D,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0x86,0x8B,0x9F,0x96,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x92,0x92,0x4F,0x99,0x8D,0x55,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \

0xA4,0xA5,0xA6,0xA7,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x45,0x45,0x45,0x4F,0x45,0x49,0x55,0x55,0x98,0x4F,0x55,0x9B,0x9C,0x55,0x55,0x9F, \

0xA0,0xA1,0x4F,0x55,0xA4,0xA5,0xA6,0xA7,0x49,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

#define TBL_CT864 {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,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

#define TBL_CT865 {0x80,0x9A,0x90,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,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \

0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

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

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \

0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}

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

0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x86,0x9C,0x8D,0x8F,0x90, \

0x91,0x90,0x92,0x95,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \

0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \

0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \

0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xA4,0xA5,0xA6,0xD9,0xDA,0xDB,0xDC,0xA7,0xA8,0xDF, \

0xA9,0xAA,0xAC,0xAD,0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xCF,0xCF,0xD0,0xEF, \

0xF0,0xF1,0xD1,0xD2,0xD3,0xF5,0xD4,0xF7,0xF8,0xF9,0xD5,0x96,0x95,0x98,0xFE,0xFF}

/* DBCS code range |----- 1st byte -----| |----------- 2nd byte -----------| */

/* <------> <------> <------> <------> <------> */

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

/* Macros for table definitions */

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

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

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

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

static FATFS* FatFs[FF_VOLUMES]; /* Pointer to the filesystem objects (logical drives) */

static WORD Fsid; /* Filesystem mount ID */

#if FF_FS_RPATH != 0

static BYTE CurrVol; /* Current drive */

#endif

#if FF_FS_LOCK != 0

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

#endif

#if FF_STR_VOLUME_ID

#ifdef FF_VOLUME_STRS

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

#endif

#endif

#if FF_LBA64

#if FF_MIN_GPT > 0x100000000

#error Wrong FF_MIN_GPT setting

#endif

static 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 /* Non-LFN configuration */

#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 /* LFN configurations */

#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

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

#endif

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

#else

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

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

#define FREE_NAMBUF()

#endif

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

#else

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

#endif

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

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

#else

#error Wrong setting of FF_USE_LFN

#endif /* FF_USE_LFN == 1 */

#endif /* FF_USE_LFN == 0 */

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

/* Code conversion tables */

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

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

#endif

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

Module Private Functions

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

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

/* Load/Store multi-byte word in the FAT structure */

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

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;

}

#endif

#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

#endif /* !FF_FS_READONLY */

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

/* String functions */

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

/* Copy memory to memory */

/*static void mem_cpy (void* dst, const void* src, UINT cnt)

{

BYTE *d = (BYTE*)dst;

const BYTE *s = (const BYTE*)src;

if (cnt != 0) {

do {

*d++ = *s++;

} while (--cnt);

}

}*/

/* Fill memory block */

/*static void mem_set (void* dst, int val, UINT cnt)

{

BYTE *d = (BYTE*)dst;

do {

*d++ = (BYTE)val;

} while (--cnt);

}*/

/* Compare memory block */

static int mem_cmp (const void* dst, const void* src, UINT cnt) /* ZR:same, NZ:different */

{

const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;

int r = 0;

do {

r = *d++ - *s++;

} while (--cnt && r == 0);

return r;

}

/* Check if chr is contained in the string */

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

{

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

return *str;

}

/* Test if the byte is DBC 1st byte */

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

#endif

return 0;

}

/* Test if the byte is DBC 2nd byte */

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

#endif

return 0;

}

#if FF_USE_LFN

/* Get a Unicode code point from the TCHAR string in defined API encodeing */

static DWORD tchar2uni ( /* Returns a character in UTF-16 encoding (>=0x10000 on surrogate pair, 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 an encoding 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 || IsSurrogate(uc)) 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;

#endif

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

return uc;

}

/* Output a TCHAR string in defined API encoding */

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

DWORD chr, /* UTF-16 encoded character (Surrogate pair if >=0x10000) */

TCHAR* buf, /* Output buffer */

UINT szb /* Size of the buffer */

)

{

#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

}

#endif /* FF_USE_LFN */

#if FF_FS_REENTRANT

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

/* Request/Release grant to access the volume */

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

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

}

}

#endif

#if FF_FS_LOCK != 0

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

/* File lock control functions */

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

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++) ;