Przeglądaj źródła

Add FatFs and SD card support (#1397)

* Add FatFs
* enable BUILD_FATFS for all-module build
* push vfs into rest of firmware
* align maximum filename length
* increase timeout for acmd41 during card initialization
* switch from DOS to Unix path semantics chdrive() is substituted by chdir()
* update to fatfs R.012a incl. patches 1-6
* add callback for rtc provisioning in file
* update docs
Arnim Läuger 7 lat temu
rodzic
commit
ecf8bd98d6
54 zmienionych plików z 41220 dodań i 444 usunięć
  1. 2 0
      app/Makefile
  2. 1 0
      app/crypto/Makefile
  3. 1 0
      app/crypto/digests.c
  4. 1 1
      app/crypto/digests.h
  5. 116 73
      app/driver/spi.c
  6. 267 0
      app/fatfs/00history.txt
  7. 21 0
      app/fatfs/00readme.txt
  8. 56 0
      app/fatfs/Makefile
  9. 115 0
      app/fatfs/diskio.c
  10. 80 0
      app/fatfs/diskio.h
  11. 24 0
      app/fatfs/fatfs_prefix_lib.h
  12. 6050 0
      app/fatfs/ff.c
  13. 366 0
      app/fatfs/ff.h
  14. 267 0
      app/fatfs/ffconf.h
  15. 38 0
      app/fatfs/integer.h
  16. 632 0
      app/fatfs/myfatfs.c
  17. 49 0
      app/fatfs/option/Makefile
  18. 3797 0
      app/fatfs/option/cc932.c
  19. 10972 0
      app/fatfs/option/cc936.c
  20. 8601 0
      app/fatfs/option/cc949.c
  21. 6827 0
      app/fatfs/option/cc950.c
  22. 315 0
      app/fatfs/option/ccsbcs.c
  23. 151 0
      app/fatfs/option/syscall.c
  24. 17 0
      app/fatfs/option/unicode.c
  25. 9 0
      app/include/driver/spi.h
  26. 24 0
      app/include/fatfs_config.h
  27. 6 1
      app/include/user_config.h
  28. 14 14
      app/lua/lauxlib.c
  29. 23 23
      app/lua/liolib.c
  30. 4 4
      app/lua/loadlib.c
  31. 1 1
      app/lua/lua.c
  32. 1 0
      app/modules/Makefile
  33. 10 5
      app/modules/crypto.c
  34. 11 11
      app/modules/enduser_setup.c
  35. 240 102
      app/modules/file.c
  36. 18 13
      app/modules/node.c
  37. 0 28
      app/platform/flash_fs.c
  38. 0 52
      app/platform/flash_fs.h
  39. 44 1
      app/platform/platform.c
  40. 2 0
      app/platform/platform.h
  41. 563 0
      app/platform/sdcard.c
  42. 17 0
      app/platform/sdcard.h
  43. 469 0
      app/platform/vfs.c
  44. 248 0
      app/platform/vfs.h
  45. 136 0
      app/platform/vfs_int.h
  46. 391 71
      app/spiffs/spiffs.c
  47. 3 1
      app/spiffs/spiffs_config.h
  48. 5 4
      app/user/user_main.c
  49. 139 38
      docs/en/modules/file.md
  50. 71 0
      docs/en/sdcard.md
  51. BIN
      docs/img/micro_sd.jpg
  52. BIN
      docs/img/micro_sd_shield.jpg
  53. 2 1
      mkdocs.yml
  54. 3 0
      tools/pr-build.sh

+ 2 - 0
app/Makefile

@@ -43,6 +43,7 @@ SUBDIRS= 					\
 	tsl2561					\
 	net					\
 	http					\
+	fatfs					\
 	websocket
 
 endif # } PDIR
@@ -83,6 +84,7 @@ COMPONENTS_eagle.app.v6 = 			\
 	ucglib/ucglib.a 			\
 	smart/smart.a 				\
 	spiffs/spiffs.a 			\
+	fatfs/libfatfs.a			\
 	cjson/libcjson.a 			\
 	crypto/libcrypto.a 			\
 	dhtlib/libdhtlib.a 			\

+ 1 - 0
app/crypto/Makefile

@@ -41,6 +41,7 @@ STD_CFLAGS=-std=gnu11 -Wimplicit
 INCLUDES := $(INCLUDES) -I $(PDIR)include
 INCLUDES += -I ./
 INCLUDES += -I ../libc
+INCLUDES += -I ../platform
 PDIR := ../$(PDIR)
 sinclude $(PDIR)Makefile
 

+ 1 - 0
app/crypto/digests.c

@@ -27,6 +27,7 @@
  * SUCH DAMAGE.
  *
  */
+#include "vfs.h"
 #include "digests.h"
 #include "user_config.h"
 #include "rom.h"

+ 1 - 1
app/crypto/digests.h

@@ -6,7 +6,7 @@
 typedef void (*create_ctx_fn)(void *ctx);
 typedef void (*update_ctx_fn)(void *ctx, const uint8_t *msg, int len);
 typedef void (*finalize_ctx_fn)(uint8_t *digest, void *ctx);
-typedef size_t ( *read_fn )(int fd, void *ptr, size_t len);
+typedef sint32_t ( *read_fn )(int fd, void *ptr, size_t len);
 
 /**
  * Description of a message digest mechanism.

+ 116 - 73
app/driver/spi.c

@@ -1,5 +1,12 @@
 #include "driver/spi.h"
 
+typedef union {
+    uint32 word[2];
+    uint64 dword;
+} spi_buf_t;
+
+static uint32_t spi_clkdiv[2];
+
 
 /******************************************************************************
  * FunctionName : spi_lcd_mode_init
@@ -59,6 +66,45 @@ void spi_lcd_9bit_write(uint8 spi_no,uint8 high_bit,uint8 low_8bit)
 	SET_PERI_REG_MASK(SPI_CMD(spi_no), SPI_USR);		//transmission start
 }
 
+/******************************************************************************
+ * FunctionName : spi_set_clkdiv
+ * Description  : Set the clock divider
+ * Parameters   : uint8 spi_no - SPI module number, Only "SPI" and "HSPI" are valid
+ *                uint32 clock_div - new clock divider
+ * Returns      : uint32 - previous clock divider
+*******************************************************************************/
+uint32_t spi_set_clkdiv(uint8 spi_no, uint32_t clock_div)
+{
+	uint32_t tmp_clkdiv;
+
+	if (spi_no > 1) return 0; //handle invalid input number
+	tmp_clkdiv = spi_clkdiv[spi_no];
+
+	if (clock_div > 1) {
+		uint8 i, k;
+		i = (clock_div / 40) ? (clock_div / 40) : 1;
+		k = clock_div / i;
+		WRITE_PERI_REG(SPI_CLOCK(spi_no),
+			       (((i - 1) & SPI_CLKDIV_PRE) << SPI_CLKDIV_PRE_S) |
+			       (((k - 1) & SPI_CLKCNT_N) << SPI_CLKCNT_N_S) |
+			       ((((k + 1) / 2 - 1) & SPI_CLKCNT_H) << SPI_CLKCNT_H_S) |
+			       (((k - 1) & SPI_CLKCNT_L) << SPI_CLKCNT_L_S)); //clear bit 31,set SPI clock div
+	} else {
+		WRITE_PERI_REG(SPI_CLOCK(spi_no), SPI_CLK_EQU_SYSCLK); // 80Mhz speed
+	}
+
+	if(spi_no==SPI){
+		WRITE_PERI_REG(PERIPHS_IO_MUX, 0x005 | (clock_div <= 1 ? 0x100 : 0));
+	}
+	else if(spi_no==HSPI){
+		WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105 | (clock_div <= 1 ? 0x200 : 0)); 
+	}
+
+	spi_clkdiv[spi_no] = clock_div;
+
+	return tmp_clkdiv;
+}
+
 /******************************************************************************
  * FunctionName : spi_master_init
  * Description  : SPI master initial function for common byte units transmission
@@ -96,28 +142,15 @@ void spi_master_init(uint8 spi_no, unsigned cpol, unsigned cpha, uint32_t clock_
 	//clear Dual or Quad lines transmission mode
 	CLEAR_PERI_REG_MASK(SPI_CTRL(spi_no), SPI_QIO_MODE|SPI_DIO_MODE|SPI_DOUT_MODE|SPI_QOUT_MODE);
 
-	if (clock_div > 1) {
-		uint8 i, k;
-		i = (clock_div / 40) ? (clock_div / 40) : 1;
-		k = clock_div / i;
-		WRITE_PERI_REG(SPI_CLOCK(spi_no),
-			       (((i - 1) & SPI_CLKDIV_PRE) << SPI_CLKDIV_PRE_S) |
-			       (((k - 1) & SPI_CLKCNT_N) << SPI_CLKCNT_N_S) |
-			       ((((k + 1) / 2 - 1) & SPI_CLKCNT_H) << SPI_CLKCNT_H_S) |
-			       (((k - 1) & SPI_CLKCNT_L) << SPI_CLKCNT_L_S)); //clear bit 31,set SPI clock div
-	} else {
-		WRITE_PERI_REG(SPI_CLOCK(spi_no), SPI_CLK_EQU_SYSCLK); // 80Mhz speed
-	}
+	spi_set_clkdiv(spi_no, clock_div);
 
 	if(spi_no==SPI){
-		WRITE_PERI_REG(PERIPHS_IO_MUX, 0x005 | (clock_div <= 1 ? 0x100 : 0));
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CLK_U, 1);//configure io to spi mode
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CMD_U, 1);//configure io to spi mode	
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA0_U, 1);//configure io to spi mode	
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA1_U, 1);//configure io to spi mode	
 	}
 	else if(spi_no==HSPI){
-		WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105 | (clock_div <= 1 ? 0x200 : 0)); 
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);//configure io to spi mode
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, 2);//configure io to spi mode	
 		PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, 2);//configure io to spi mode	
@@ -125,6 +158,44 @@ void spi_master_init(uint8 spi_no, unsigned cpol, unsigned cpha, uint32_t clock_
 	}
 }
 
+void spi_mast_byte_order(uint8 spi_no, uint8 order)
+{
+    if(spi_no > 1)
+        return;
+
+    if (order == SPI_ORDER_MSB) {
+	SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_RD_BYTE_ORDER | SPI_WR_BYTE_ORDER);
+    } else if (order == SPI_ORDER_LSB) {
+	CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_RD_BYTE_ORDER | SPI_WR_BYTE_ORDER);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : spi_mast_blkset
+ * Description  : Copy a block of data to the MOSI FIFO
+ * Parameters   : uint8  spi_no - SPI module number, Only "SPI" and "HSPI" are valid
+ *                size_t bitlen - number of bits to copy, multiple of 8
+ *                uint8  *data  - pointer to data buffer
+*******************************************************************************/
+void spi_mast_blkset(uint8 spi_no, size_t bitlen, const uint8 *data)
+{
+    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
+    os_memcpy((void *)SPI_W0(spi_no), (const void *)data, bitlen >> 3);
+}
+
+/******************************************************************************
+ * FunctionName : spi_mast_blkget
+ * Description  : Copy a block of data from the MISO FIFO
+ * Parameters   : uint8  spi_no - SPI module number, Only "SPI" and "HSPI" are valid
+ *                size_t bitlen - number of bits to copy, multiple of 8
+ *                uint8  *data  - pointer to data buffer
+*******************************************************************************/
+void spi_mast_blkget(uint8 spi_no, size_t bitlen, uint8 *data)
+{
+    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
+    os_memcpy((void *)data, (void *)SPI_W0(spi_no), bitlen >> 3);
+}
+
 /******************************************************************************
  * FunctionName : spi_mast_set_mosi
  * Description  : Enter provided data into MOSI buffer.
@@ -137,48 +208,36 @@ void spi_master_init(uint8 spi_no, unsigned cpol, unsigned cpha, uint32_t clock_
 *******************************************************************************/
 void spi_mast_set_mosi(uint8 spi_no, uint16 offset, uint8 bitlen, uint32 data)
 {
-    uint8  wn, wn_offset, wn_bitlen;
-    uint32 wn_data;
+    uint8     wn, shift;
+    spi_buf_t spi_buf;
 
     if (spi_no > 1)
         return; // handle invalid input number
     if (bitlen > 32)
         return; // handle invalid input number
 
-    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
-
     // determine which SPI_Wn register is addressed
     wn = offset >> 5;
-    if (wn > 15)
+    if (wn > 15) {
         return; // out of range
-    wn_offset = offset & 0x1f;
-    if (32 - wn_offset < bitlen)
-    {
-        // splitting required
-        wn_bitlen = 32 - wn_offset;
-        wn_data   = data >> (bitlen - wn_bitlen);
     }
-    else
-    {
-        wn_bitlen = bitlen;
-        wn_data   = data;
+
+    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
+
+    // transfer Wn to buf
+    spi_buf.word[1] = READ_PERI_REG(SPI_W0(spi_no) + wn*4);
+    if (wn < 15) {
+        spi_buf.word[0] = READ_PERI_REG(SPI_W0(spi_no) + (wn+1)*4);
     }
 
-    do
-    {
-        // write payload data to SPI_Wn
-        SET_PERI_REG_BITS(REG_SPI_BASE(spi_no) +0x40 + wn*4, BIT(wn_bitlen) - 1, wn_data, 32 - (wn_offset + wn_bitlen));
-
-        // prepare writing of dangling data part
-        wn += 1;
-        wn_offset = 0;
-        if (wn <= 15)
-            bitlen -= wn_bitlen;
-        else
-            bitlen = 0; // force abort
-        wn_bitlen = bitlen;
-        wn_data   = data;
-    } while (bitlen > 0);
+    shift = 64 - (offset & 0x1f) - bitlen;
+    spi_buf.dword &= ~((1ULL << bitlen)-1 << shift);
+    spi_buf.dword |= (uint64)data << shift;
+
+    if (wn < 15) {
+       WRITE_PERI_REG(SPI_W0(spi_no) + (wn+1)*4, spi_buf.word[0]);
+    }
+    WRITE_PERI_REG(SPI_W0(spi_no) + wn*4, spi_buf.word[1]);
 
     return;
 }
@@ -194,46 +253,30 @@ void spi_mast_set_mosi(uint8 spi_no, uint16 offset, uint8 bitlen, uint32 data)
 *******************************************************************************/
 uint32 spi_mast_get_miso(uint8 spi_no, uint16 offset, uint8 bitlen)
 {
-    uint8  wn, wn_offset, wn_bitlen;
-    uint32 wn_data = 0;
+    uint8     wn;
+    spi_buf_t spi_buf;
+    uint32    result;
 
     if (spi_no > 1)
         return 0; // handle invalid input number
 
-    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
-
     // determine which SPI_Wn register is addressed
     wn = offset >> 5;
     if (wn > 15)
         return 0; // out of range
-    wn_offset = offset & 0x1f;
 
-    if (bitlen > (32 - wn_offset))
-    {
-        // splitting required
-        wn_bitlen = 32 - wn_offset;
-    }
-    else
-    {
-        wn_bitlen = bitlen;
+    while(READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR);
+
+    // transfer Wn to buf
+    spi_buf.word[1] = READ_PERI_REG(SPI_W0(spi_no) + wn*4);
+    if (wn < 15) {
+        spi_buf.word[0] = READ_PERI_REG(SPI_W0(spi_no) + (wn+1)*4);
     }
 
-    do
-    {
-        wn_data |= (READ_PERI_REG(REG_SPI_BASE(spi_no) +0x40 + wn*4) >> (32 - (wn_offset + wn_bitlen))) & (BIT(wn_bitlen) - 1);
-
-        // prepare reading of dangling data part
-        wn_data <<= bitlen - wn_bitlen;
-        wn += 1;
-        wn_offset = 0;
-        if (wn <= 15)
-            bitlen -= wn_bitlen;
-        else
-            bitlen = 0; // force abort
-        wn_bitlen = bitlen;
-    } while (bitlen > 0);
-
-    return wn_data;
+    result = (uint32)(spi_buf.dword >> (64 - ((offset & 0x1f) + bitlen)));
+    result &= (1UL << bitlen)-1;
+
+    return result;
 }
 
 /******************************************************************************

+ 267 - 0
app/fatfs/00history.txt

@@ -0,0 +1,267 @@
+----------------------------------------------------------------------------
+  Revision history of FatFs module
+----------------------------------------------------------------------------
+
+R0.00 (February 26, 2006)
+
+  Prototype.
+
+
+
+R0.01 (April 29, 2006)
+
+  The first release.
+
+
+
+R0.02 (June 01, 2006)
+
+  Added FAT12 support.
+  Removed unbuffered mode.
+  Fixed a problem on small (<32M) partition.
+
+
+
+R0.02a (June 10, 2006)
+
+  Added a configuration option (_FS_MINIMUM).
+
+
+
+R0.03 (September 22, 2006)
+
+  Added f_rename().
+  Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+
+
+R0.03a (December 11, 2006)
+
+  Improved cluster scan algorithm to write files fast.
+  Fixed f_mkdir() creates incorrect directory on FAT32.
+
+
+
+R0.04 (February 04, 2007)
+
+  Added f_mkfs().
+  Supported multiple drive system.
+  Changed some interfaces for multiple drive system.
+  Changed f_mountdrv() to f_mount().
+
+
+
+R0.04a (April 01, 2007)
+
+  Supported multiple partitions on a physical drive.
+  Added a capability of extending file size to f_lseek().
+  Added minimization level 3.
+  Fixed an endian sensitive code in f_mkfs().
+
+
+
+R0.04b (May 05, 2007)
+
+  Added a configuration option _USE_NTFLAG.
+  Added FSINFO support.
+  Fixed DBCS name can result FR_INVALID_NAME.
+  Fixed short seek (<= csize) collapses the file object.
+
+
+
+R0.05 (August 25, 2007)
+
+  Changed arguments of f_read(), f_write() and f_mkfs().
+  Fixed f_mkfs() on FAT32 creates incorrect FSINFO.
+  Fixed f_mkdir() on FAT32 creates incorrect directory.
+
+
+
+R0.05a (February 03, 2008)
+
+  Added f_truncate() and f_utime().
+  Fixed off by one error at FAT sub-type determination.
+  Fixed btr in f_read() can be mistruncated.
+  Fixed cached sector is not flushed when create and close without write.
+
+
+
+R0.06 (April 01, 2008)
+
+  Added fputc(), fputs(), fprintf() and fgets().
+  Improved performance of f_lseek() on moving to the same or following cluster.
+
+
+
+R0.07 (April 01, 2009)
+
+  Merged Tiny-FatFs as a configuration option. (_FS_TINY)
+  Added long file name feature. (_USE_LFN)
+  Added multiple code page feature. (_CODE_PAGE)
+  Added re-entrancy for multitask operation. (_FS_REENTRANT)
+  Added auto cluster size selection to f_mkfs().
+  Added rewind option to f_readdir().
+  Changed result code of critical errors.
+  Renamed string functions to avoid name collision.
+
+
+
+R0.07a (April 14, 2009)
+
+  Septemberarated out OS dependent code on reentrant cfg.
+  Added multiple sector size feature.
+
+
+
+R0.07c (June 21, 2009)
+
+  Fixed f_unlink() can return FR_OK on error.
+  Fixed wrong cache control in f_lseek().
+  Added relative path feature.
+  Added f_chdir() and f_chdrive().
+  Added proper case conversion to extended character.
+
+
+
+R0.07e (November 03, 2009)
+
+  Septemberarated out configuration options from ff.h to ffconf.h.
+  Fixed f_unlink() fails to remove a sub-directory on _FS_RPATH.
+  Fixed name matching error on the 13 character boundary.
+  Added a configuration option, _LFN_UNICODE.
+  Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
+
+
+
+R0.08 (May 15, 2010)
+
+  Added a memory configuration option. (_USE_LFN = 3)
+  Added file lock feature. (_FS_SHARE)
+  Added fast seek feature. (_USE_FASTSEEK)
+  Changed some types on the API, XCHAR->TCHAR.
+  Changed .fname in the FILINFO structure on Unicode cfg.
+  String functions support UTF-8 encoding files on Unicode cfg.
+
+
+
+R0.08a (August 16, 2010)
+
+  Added f_getcwd(). (_FS_RPATH = 2)
+  Added sector erase feature. (_USE_ERASE)
+  Moved file lock semaphore table from fs object to the bss.
+  Fixed f_mkfs() creates wrong FAT32 volume.
+
+
+
+R0.08b (January 15, 2011)
+
+  Fast seek feature is also applied to f_read() and f_write().
+  f_lseek() reports required table size on creating CLMP.
+  Extended format syntax of f_printf().
+  Ignores duplicated directory separators in given path name.
+
+
+
+R0.09 (September 06, 2011)
+
+  f_mkfs() supports multiple partition to complete the multiple partition feature.
+  Added f_fdisk().
+
+
+
+R0.09a (August 27, 2012)
+
+  Changed f_open() and f_opendir() reject null object pointer to avoid crash.
+  Changed option name _FS_SHARE to _FS_LOCK.
+  Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
+
+
+
+R0.09b (January 24, 2013)
+
+  Added f_setlabel() and f_getlabel().
+
+
+
+R0.10 (October 02, 2013)
+
+  Added selection of character encoding on the file. (_STRF_ENCODE)
+  Added f_closedir().
+  Added forced full FAT scan for f_getfree(). (_FS_NOFSINFO)
+  Added forced mount feature with changes of f_mount().
+  Improved behavior of volume auto detection.
+  Improved write throughput of f_puts() and f_printf().
+  Changed argument of f_chdrive(), f_mkfs(), disk_read() and disk_write().
+  Fixed f_write() can be truncated when the file size is close to 4GB.
+  Fixed f_open(), f_mkdir() and f_setlabel() can return incorrect value on error.
+
+
+
+R0.10a (January 15, 2014)
+
+  Added arbitrary strings as drive number in the path name. (_STR_VOLUME_ID)
+  Added a configuration option of minimum sector size. (_MIN_SS)
+  2nd argument of f_rename() can have a drive number and it will be ignored.
+  Fixed f_mount() with forced mount fails when drive number is >= 1. (appeared at R0.10)
+  Fixed f_close() invalidates the file object without volume lock.
+  Fixed f_closedir() returns but the volume lock is left acquired. (appeared at R0.10)
+  Fixed creation of an entry with LFN fails on too many SFN collisions. (appeared at R0.07)
+
+
+
+R0.10b (May 19, 2014)
+
+  Fixed a hard error in the disk I/O layer can collapse the directory entry.
+  Fixed LFN entry is not deleted on delete/rename an object with lossy converted SFN. (appeared at R0.07)
+
+
+
+R0.10c (November 09, 2014)
+
+  Added a configuration option for the platforms without RTC. (_FS_NORTC)
+  Changed option name _USE_ERASE to _USE_TRIM.
+  Fixed volume label created by Mac OS X cannot be retrieved with f_getlabel(). (appeared at R0.09b)
+  Fixed a potential problem of FAT access that can appear on disk error.
+  Fixed null pointer dereference on attempting to delete the root direcotry. (appeared at R0.08)
+
+
+
+R0.11 (February 09, 2015)
+
+  Added f_findfirst(), f_findnext() and f_findclose(). (_USE_FIND)
+  Fixed f_unlink() does not remove cluster chain of the file. (appeared at R0.10c)
+  Fixed _FS_NORTC option does not work properly. (appeared at R0.10c)
+
+
+
+R0.11a (September 05, 2015)
+
+  Fixed wrong media change can lead a deadlock at thread-safe configuration.
+  Added code page 771, 860, 861, 863, 864, 865 and 869. (_CODE_PAGE)
+  Removed some code pages actually not exist on the standard systems. (_CODE_PAGE)
+  Fixed errors in the case conversion teble of code page 437 and 850 (ff.c).
+  Fixed errors in the case conversion teble of Unicode (cc*.c).
+
+
+
+R0.12 (April 12, 2016)
+
+  Added support for exFAT file system. (_FS_EXFAT)
+  Added f_expand(). (_USE_EXPAND)
+  Changed some members in FINFO structure and behavior of f_readdir().
+  Added an option _USE_CHMOD.
+  Removed an option _WORD_ACCESS.
+  Fixed errors in the case conversion table of Unicode (cc*.c).
+
+
+
+R0.12a (July 10, 2016)
+
+  Added support for creating exFAT volume with some changes of f_mkfs().
+  Added a file open method FA_OPEN_APPEND. An f_lseek() following f_open() is no longer needed.
+  f_forward() is available regardless of _FS_TINY.
+  Fixed f_mkfs() creates wrong volume.
+  Fixed compilation fails at some configurations, _USE_FASTSEEK and _USE_FORWARD.
+  Fixed wrong memory read in create_name().
+
+

+ 21 - 0
app/fatfs/00readme.txt

@@ -0,0 +1,21 @@
+FatFs Module Source Files R0.12a
+
+
+FILES
+
+  00readme.txt This file.
+  history.txt  Revision history.
+  ffconf.h     Configuration file for FatFs module.
+  ff.h         Common include file for FatFs and application module.
+  ff.c         FatFs module.
+  diskio.h     Common include file for FatFs and disk I/O module.
+  diskio.c     An example of glue function to attach existing disk I/O module to FatFs.
+  integer.h    Integer type definitions for FatFs.
+  option       Optional external functions.
+
+
+  Low level disk I/O module is not included in this archive because the FatFs
+  module is only a generic file system layer and not depend on any specific
+  storage device. You have to provide a low level disk I/O module that written
+  to control the target storage device.
+

+ 56 - 0
app/fatfs/Makefile

@@ -0,0 +1,56 @@
+
+#############################################################
+# Required variables for each makefile
+# Discard this section from all parent makefiles
+# Expected variables (with automatic defaults):
+#   CSRCS (all "C" files in the dir)
+#   SUBDIRS (all subdirs with a Makefile)
+#   GEN_LIBS - list of libs to be generated ()
+#   GEN_IMAGES - list of images to be generated ()
+#   COMPONENTS_xxx - a list of libs/objs in the form
+#     subdir/lib to be extracted and rolled up into
+#     a generated lib/image xxx.a ()
+#
+ifndef PDIR
+
+UP_EXTRACT_DIR = ..
+GEN_LIBS = libfatfs.a
+COMPONENTS_libfatfs = option/liboption.a
+
+endif
+
+ifndef FATFS_INC_DIR
+FATFS_INC_DIR = ./
+endif
+
+STD_CFLAGS=-std=gnu11 -Wimplicit -imacros $(FATFS_INC_DIR)fatfs_prefix_lib.h
+
+#############################################################
+# Configuration i.e. compile options etc.
+# Target specific stuff (defines etc.) goes in here!
+# Generally values applying to a tree are captured in the
+#   makefile at its root level - these are then overridden
+#   for a subtree within the makefile rooted therein
+#
+#DEFINES += 
+
+#############################################################
+# Recursion Magic - Don't touch this!!
+#
+# Each subtree potentially has an include directory
+#   corresponding to the common APIs applicable to modules
+#   rooted at that subtree. Accordingly, the INCLUDE PATH
+#   of a module can only contain the include directories up
+#   its parent path, and not its siblings
+#
+# Required for each makefile to inherit from the parent
+#
+
+INCLUDES := $(INCLUDES) -I $(PDIR)include
+INCLUDES += -I ./
+INCLUDES += -I ../platform
+INCLUDES += -I ../libc
+INCLUDES += -I ../lua
+PDIR := ../$(PDIR)
+sinclude $(PDIR)Makefile
+

+ 115 - 0
app/fatfs/diskio.c

@@ -0,0 +1,115 @@
+/*-----------------------------------------------------------------------*/
+/* 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 "sdcard.h"
+
+static DSTATUS m_status = STA_NOINIT;
+
+/*-----------------------------------------------------------------------*/
+/* Get Drive Status                                                      */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+	BYTE pdrv		/* Physical drive nmuber to identify the drive */
+)
+{
+  return m_status;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+	BYTE pdrv				/* Physical drive nmuber to identify the drive */
+)
+{
+  int result;
+
+  if (platform_sdcard_init( 1, pdrv )) {
+    m_status &= ~STA_NOINIT;
+  }
+
+  return m_status;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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 */
+)
+{
+  if (count == 1) {
+    if (! platform_sdcard_read_block( pdrv, sector, buff )) {
+      return RES_ERROR;
+    }
+  } else {
+    if (! platform_sdcard_read_blocks( pdrv, sector, count, buff )) {
+      return RES_ERROR;
+    }
+  }
+
+  return RES_OK;
+}
+
+
+/*-----------------------------------------------------------------------*/
+/* 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 */
+)
+{
+  if (count == 1) {
+    if (! platform_sdcard_write_block( pdrv, sector, buff )) {
+      return RES_ERROR;
+    }
+  } else {
+    if (! platform_sdcard_write_blocks( pdrv, sector, count, buff )) {
+      return RES_ERROR;
+    }
+  }
+
+  return RES_OK;
+}
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,		/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+  switch (cmd) {
+  case CTRL_TRIM:    /* no-op */
+  case CTRL_SYNC:    /* no-op */
+    return RES_OK;
+
+  default:           /* anything else throws parameter error */
+    return RES_PARERR;
+  }
+}

+ 80 - 0
app/fatfs/diskio.h

@@ -0,0 +1,80 @@
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2014          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "integer.h"
+
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+
+DSTATUS disk_initialize (BYTE pdrv);
+DSTATUS disk_status (BYTE pdrv);
+DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
+DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
+DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+/* Command code for disk_ioctrl fucntion */
+
+/* Generic command (Used by FatFs) */
+#define CTRL_SYNC			0	/* Complete pending write process (needed at _FS_READONLY == 0) */
+#define GET_SECTOR_COUNT	1	/* Get media size (needed at _USE_MKFS == 1) */
+#define GET_SECTOR_SIZE		2	/* Get sector size (needed at _MAX_SS != _MIN_SS) */
+#define GET_BLOCK_SIZE		3	/* Get erase block size (needed at _USE_MKFS == 1) */
+#define CTRL_TRIM			4	/* Inform device that the data on the block of sectors is no longer used (needed at _USE_TRIM == 1) */
+
+/* Generic command (Not used by FatFs) */
+#define CTRL_POWER			5	/* Get/Set power status */
+#define CTRL_LOCK			6	/* Lock/Unlock media removal */
+#define CTRL_EJECT			7	/* Eject media */
+#define CTRL_FORMAT			8	/* Create physical format on the media */
+
+/* MMC/SDC specific ioctl command */
+#define MMC_GET_TYPE		10	/* Get card type */
+#define MMC_GET_CSD			11	/* Get CSD */
+#define MMC_GET_CID			12	/* Get CID */
+#define MMC_GET_OCR			13	/* Get OCR */
+#define MMC_GET_SDSTAT		14	/* Get SD status */
+#define ISDIO_READ			55	/* Read data form SD iSDIO register */
+#define ISDIO_WRITE			56	/* Write data to SD iSDIO register */
+#define ISDIO_MRITE			57	/* Masked write data to SD iSDIO register */
+
+/* ATA/CF specific ioctl command */
+#define ATA_GET_REV			20	/* Get F/W revision */
+#define ATA_GET_MODEL		21	/* Get model name */
+#define ATA_GET_SN			22	/* Get serial number */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

+ 24 - 0
app/fatfs/fatfs_prefix_lib.h

@@ -0,0 +1,24 @@
+
+#define f_chdir    fatfslib_f_chdir
+#define f_chdrive  fatfslib_f_chdrive
+#define f_chmod    fatfslib_f_chmod
+#define f_close    fatfslib_f_close
+#define f_closedir fatfslib_f_closedir
+#define f_getcwd   fatfslib_f_getcwd
+#define f_getfree  fatfslib_f_getfree
+#define f_getlabel fatfslib_f_getlabel
+#define f_lseek    fatfslib_f_lseek
+#define f_mkdir    fatfslib_f_mkdir
+#define f_mount    fatfslib_f_mount
+#define f_open     fatfslib_f_open
+#define f_opendir  fatfslib_f_opendir
+#define f_read     fatfslib_f_read
+#define f_readdir  fatfslib_f_readdir
+#define f_rename   fatfslib_f_rename
+#define f_setlabel fatfslib_f_setlabel
+#define f_stat     fatfslib_f_stat
+#define f_sync     fatfslib_f_sync
+#define f_truncate fatfslib_f_truncate
+#define f_unlink   fatfslib_f_unlink
+#define f_utime    fatfslib_f_utime
+#define f_write    fatfslib_f_write

+ 6050 - 0
app/fatfs/ff.c

@@ -0,0 +1,6050 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT file system module  R0.12a                             /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2016, 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 */
+
+
+/*--------------------------------------------------------------------------
+
+   Module Private Definitions
+
+---------------------------------------------------------------------------*/
+
+#if _FATFS != 80186	/* Revision ID */
+#error Wrong include file (ff.h).
+#endif
+
+
+#define	ABORT(fs, res)		{ fp->err = (BYTE)(res); LEAVE_FF(fs, res); }
+
+
+/* Reentrancy related */
+#if _FS_REENTRANT
+#if _USE_LFN == 1
+#error Static LFN work area cannot be used at thread-safe configuration
+#endif
+#define	ENTER_FF(fs)		{ if (!lock_fs(fs)) return FR_TIMEOUT; }
+#define	LEAVE_FF(fs, res)	{ unlock_fs(fs, res); return res; }
+#else
+#define	ENTER_FF(fs)
+#define LEAVE_FF(fs, res)	return res
+#endif
+
+
+
+/* Definitions of sector size */
+#if (_MAX_SS < _MIN_SS) || (_MAX_SS != 512 && _MAX_SS != 1024 && _MAX_SS != 2048 && _MAX_SS != 4096) || (_MIN_SS != 512 && _MIN_SS != 1024 && _MIN_SS != 2048 && _MIN_SS != 4096)
+#error Wrong sector size configuration
+#endif
+#if _MAX_SS == _MIN_SS
+#define	SS(fs)	((UINT)_MAX_SS)	/* Fixed sector size */
+#else
+#define	SS(fs)	((fs)->ssize)	/* Variable sector size */
+#endif
+
+
+/* Timestamp */
+#if _FS_NORTC == 1
+#if _NORTC_YEAR < 1980 || _NORTC_YEAR > 2107 || _NORTC_MON < 1 || _NORTC_MON > 12 || _NORTC_MDAY < 1 || _NORTC_MDAY > 31
+#error Invalid _FS_NORTC settings
+#endif
+#define GET_FATTIME()	((DWORD)(_NORTC_YEAR - 1980) << 25 | (DWORD)_NORTC_MON << 21 | (DWORD)_NORTC_MDAY << 16)
+#else
+#define GET_FATTIME()	get_fattime()
+#endif
+
+
+/* File lock controls */
+#if _FS_LOCK != 0
+#if _FS_READONLY
+#error _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, directory (0:root) */
+	DWORD ofs;		/* Object ID 3, directory offset */
+	WORD ctr;		/* Object open counter, 0:none, 0x01..0xFF:read mode open count, 0x100:write mode */
+} FILESEM;
+#endif
+
+
+
+/* DBCS code ranges and SBCS upper conversion tables */
+
+#if _CODE_PAGE == 932	/* Japanese Shift-JIS */
+#define _DF1S	0x81	/* DBC 1st byte range 1 start */
+#define _DF1E	0x9F	/* DBC 1st byte range 1 end */
+#define _DF2S	0xE0	/* DBC 1st byte range 2 start */
+#define _DF2E	0xFC	/* DBC 1st byte range 2 end */
+#define _DS1S	0x40	/* DBC 2nd byte range 1 start */
+#define _DS1E	0x7E	/* DBC 2nd byte range 1 end */
+#define _DS2S	0x80	/* DBC 2nd byte range 2 start */
+#define _DS2E	0xFC	/* DBC 2nd byte range 2 end */
+
+#elif _CODE_PAGE == 936	/* Simplified Chinese GBK */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0x80
+#define _DS2E	0xFE
+
+#elif _CODE_PAGE == 949	/* Korean */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x41
+#define _DS1E	0x5A
+#define _DS2S	0x61
+#define _DS2E	0x7A
+#define _DS3S	0x81
+#define _DS3E	0xFE
+
+#elif _CODE_PAGE == 950	/* Traditional Chinese Big5 */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0xA1
+#define _DS2E	0xFE
+
+#elif _CODE_PAGE == 437	/* U.S. */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 720	/* Arabic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 737	/* Greek */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 771	/* KBL */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 775	/* Baltic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 850	/* Latin 1 */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 852	/* Latin 2 */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 855	/* Cyrillic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 857	/* Turkish */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 860	/* Portuguese */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 861	/* Icelandic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 862	/* Hebrew */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 863	/* Canadian-French */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 864	/* Arabic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 865	/* Nordic */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 866	/* Russian */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 869	/* Greek 2 */
+#define _DF1S	0
+#define _EXCVT {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}
+
+#elif _CODE_PAGE == 1	/* ASCII (for only non-LFN cfg) */
+#if _USE_LFN != 0
+#error Cannot enable LFN without valid code page.
+#endif
+#define _DF1S	0
+
+#else
+#error Unknown code page
+
+#endif
+
+
+/* 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'))
+
+#if _DF1S != 0	/* Code page is DBCS */
+
+#ifdef _DF2S	/* Two 1st byte areas */
+#define IsDBCS1(c)	(((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#else			/* One 1st byte area */
+#define IsDBCS1(c)	((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
+#endif
+
+#ifdef _DS3S	/* Three 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#else			/* Two 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#endif
+
+#else			/* Code page is SBCS */
+
+#define IsDBCS1(c)	0
+#define IsDBCS2(c)	0
+
+#endif /* _DF1S */
+
+
+/* File attribute bits (internal use) */
+#define	AM_VOL		0x08	/* Volume label */
+#define AM_LFN		0x0F	/* LFN entry */
+#define AM_MASK		0x3F	/* Mask of defined bits */
+
+
+/* File access control and file status flags (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 */
+
+
+/* Name status flags */
+#define NSFLAG		11		/* Index of name status byte in fn[] */
+#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 */
+
+
+/* Limits and boundaries (differ from specs but correct for real DOS/Windows) */
+#define MAX_FAT12	0xFF5			/* Maximum number of FAT12 clusters */
+#define	MAX_FAT16	0xFFF5			/* Maximum number of FAT16 clusters */
+#define	MAX_FAT32	0xFFFFFF5		/* Maximum number of FAT32 clusters */
+#define	MAX_EXFAT	0x7FFFFFFD		/* Maximum number of exFAT clusters (limited by implementation) */
+#define MAX_DIR		0x200000		/* Maximum size of FAT directory */
+#define MAX_DIR_EX	0x10000000		/* Maximum size of exFAT directory */
+
+
+/* FatFs refers the members in the FAT structures as byte array instead of
+/ structure members because the 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 FAT12/16 [entry] (WORD) */
+#define BPB_TotSec16		19		/* Volume size (16-bit) [sector] (WORD) */
+#define BPB_Media			21		/* Media descriptor (BYTE) */
+#define BPB_FATSz16			22		/* FAT size (16-bit) [sector] (WORD) */
+#define BPB_SecPerTrk		24		/* Track size 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		/* 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		/* File system type string (8-byte) */
+#define BS_BootCode			62		/* Boot code (448-byte) */
+
+#define BPB_FATSz32			36		/* FAT32: FAT size [sector] (DWORD) */
+#define BPB_ExtFlags32		40		/* FAT32: Extended flags (WORD) */
+#define BPB_FSVer32			42		/* FAT32: File system 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: File system 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 cluster (DWORD) */
+#define BPB_VolIDEx			100		/* exFAT: Volume serial number (DWORD) */
+#define BPB_FSVerEx			104		/* exFAT: File system version (WORD) */
+#define BPB_VolFlagEx		106		/* exFAT: Volume flags (BYTE) */
+#define BPB_ActFatEx		107		/* exFAT: Active FAT flags (BYTE) */
+#define BPB_BytsPerSecEx	108		/* exFAT: Log2 of sector size in byte (BYTE) */
+#define BPB_SecPerClusEx	109		/* exFAT: Log2 of cluster size in 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	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 BS_55AA				510		/* Signature word (WORD) */
+
+#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 entry order and LLE flag (BYTE) */
+#define	LDIR_Attr			11		/* LFN attribute (BYTE) */
+#define	LDIR_Type			12		/* LFN type (BYTE) */
+#define	LDIR_Chksum			13		/* Checksum of the SFN entry (BYTE) */
+#define	LDIR_FstClusLO		26		/* Must be zero (WORD) */
+#define	XDIR_Type			0		/* Type of exFAT directory entry (BYTE) */
+#define	XDIR_NumLabel		1		/* Number of volume label characters (BYTE) */
+#define	XDIR_Label			2		/* Volume label (11-WORD) */
+#define	XDIR_CaseSum		4		/* Sum of case conversion table (DWORD) */
+#define	XDIR_NumSec			1		/* Number of secondary entries (BYTE) */
+#define	XDIR_SetSum			2		/* Sum of the set of directory entries (WORD) */
+#define	XDIR_Attr			4		/* File attribute (WORD) */
+#define	XDIR_CrtTime		8		/* Created time (DWORD) */
+#define	XDIR_ModTime		12		/* Modified time (DWORD) */
+#define	XDIR_AccTime		16		/* Last accessed time (DWORD) */
+#define	XDIR_CrtTime10		20		/* Created time subsecond (BYTE) */
+#define	XDIR_ModTime10		21		/* Modified time subsecond (BYTE) */
+#define	XDIR_CrtTZ			22		/* Created timezone (BYTE) */
+#define	XDIR_ModTZ			23		/* Modified timezone (BYTE) */
+#define	XDIR_AccTZ			24		/* Last accessed timezone (BYTE) */
+#define	XDIR_GenFlags		33		/* Gneral secondary flags (WORD) */
+#define	XDIR_NumName		35		/* Number of file name characters (BYTE) */
+#define	XDIR_NameHash		36		/* Hash of file name (WORD) */
+#define XDIR_ValidFileSize	40		/* Valid file size (QWORD) */
+#define	XDIR_FstClus		52		/* First cluster of the file data (DWORD) */
+#define	XDIR_FileSize		56		/* File/Directory size (QWORD) */
+
+#define	SZDIRE				32		/* Size of a directory entry */
+#define	LLEF				0x40	/* Last long entry flag in LDIR_Ord */
+#define	DDEM				0xE5	/* Deleted directory entry mark set to DIR_Name[0] */
+#define	RDDEM				0x05	/* Replacement of the character collides with DDEM */
+
+
+
+
+
+/*--------------------------------------------------------------------------
+
+   Module Private Work Area
+
+---------------------------------------------------------------------------*/
+
+/* Remark: Variables here without initial value shall be guaranteed zero/null
+/  at start-up. If not, either the linker or start-up routine being used is
+/  not compliance with C standard. */
+
+#if _VOLUMES < 1 || _VOLUMES > 9
+#error Wrong _VOLUMES setting
+#endif
+static FATFS *FatFs[_VOLUMES];	/* Pointer to the file system objects (logical drives) */
+static WORD Fsid;				/* File system mount ID */
+
+#if _FS_RPATH != 0 && _VOLUMES >= 2
+static BYTE CurrVol;			/* Current drive */
+#endif
+
+#if _FS_LOCK != 0
+static FILESEM Files[_FS_LOCK];	/* Open object lock semaphores */
+#endif
+
+#if _USE_LFN == 0			/* Non-LFN configuration */
+#define	DEF_NAMBUF
+#define INIT_NAMBUF(fs)
+#define	FREE_NAMBUF()
+#else
+#if _MAX_LFN < 12 || _MAX_LFN > 255
+#error Wrong _MAX_LFN setting
+#endif
+
+#if _USE_LFN == 1		/* LFN enabled with static working buffer */
+#if _FS_EXFAT
+static BYTE	DirBuf[SZDIRE*19];	/* Directory entry block scratchpad buffer (19 entries in size) */
+#endif
+static WCHAR LfnBuf[_MAX_LFN+1];	/* LFN enabled with static working buffer */
+#define	DEF_NAMBUF
+#define INIT_NAMBUF(fs)
+#define	FREE_NAMBUF()
+
+#elif _USE_LFN == 2 	/* LFN enabled with dynamic working buffer on the stack */
+#if _FS_EXFAT
+#define	DEF_NAMBUF		WCHAR lbuf[_MAX_LFN+1]; BYTE dbuf[SZDIRE*19];
+#define INIT_NAMBUF(fs)	{ (fs)->lfnbuf = lbuf; (fs)->dirbuf = dbuf; }
+#define	FREE_NAMBUF()
+#else
+#define	DEF_NAMBUF		WCHAR lbuf[_MAX_LFN+1];
+#define INIT_NAMBUF(fs)	{ (fs)->lfnbuf = lbuf; }
+#define	FREE_NAMBUF()
+#endif
+
+#elif _USE_LFN == 3 	/* LFN enabled with dynamic working buffer on the heap */
+#if _FS_EXFAT
+#define	DEF_NAMBUF		WCHAR *lfn;
+#define INIT_NAMBUF(fs)	{ lfn = ff_memalloc((_MAX_LFN+1)*2 + SZDIRE*19); if (!lfn) LEAVE_FF(fs, FR_NOT_ENOUGH_CORE); (fs)->lfnbuf = lfn; (fs)->dirbuf = (BYTE*)(lfn+_MAX_LFN+1); }
+#define	FREE_NAMBUF()	ff_memfree(lfn)
+#else
+#define	DEF_NAMBUF		WCHAR *lfn;
+#define INIT_NAMBUF(fs)	{ lfn = ff_memalloc((_MAX_LFN+1)*2); if (!lfn) LEAVE_FF(fs, FR_NOT_ENOUGH_CORE); (fs)->lfnbuf = lfn; }
+#define	FREE_NAMBUF()	ff_memfree(lfn)
+#endif
+
+#else
+#error Wrong _USE_LFN setting
+#endif
+#endif
+
+#ifdef _EXCVT
+static const BYTE ExCvt[] = _EXCVT;	/* Upper conversion table for SBCS extended characters */
+#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 _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 !_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 _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	/* !_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) {
+		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;
+}
+
+
+
+
+#if _FS_REENTRANT
+/*-----------------------------------------------------------------------*/
+/* Request/Release grant to access the volume                            */
+/*-----------------------------------------------------------------------*/
+static
+int lock_fs (
+	FATFS* fs		/* File system object */
+)
+{
+	return ff_req_grant(fs->sobj);
+}
+
+
+static
+void unlock_fs (
+	FATFS* fs,		/* File system 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 _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, 1:Write, 2:Delete/Rename) */
+)
+{
+	UINT i, be;
+
+	/* Search file semaphore table */
+	for (i = be = 0; i < _FS_LOCK; i++) {
+		if (Files[i].fs) {	/* Existing entry */
+			if (Files[i].fs == dp->obj.fs &&	 	/* Check if the object matched with an open object */
+				Files[i].clu == dp->obj.sclust &&
+				Files[i].ofs == dp->dptr) break;
+		} else {			/* Blank entry */
+			be = 1;
+		}
+	}
+	if (i == _FS_LOCK) {	/* The object is not opened */
+		return (be || acc == 2) ? FR_OK : FR_TOO_MANY_OPEN_FILES;	/* Is there a blank entry for new object? */
+	}
+
+	/* The object has been opened. Reject any open against writing file and all write mode open */
+	return (acc || 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 < _FS_LOCK && Files[i].fs; i++) ;
+	return (i == _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 < _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 == _FS_LOCK) {				/* Not opened. Register it as new. */
+		for (i = 0; i < _FS_LOCK && Files[i].fs; i++) ;
+		if (i == _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 && Files[i].ctr) return 0;	/* Access violation (int err) */
+
+	Files[i].ctr = acc ? 0x100 : Files[i].ctr + 1;	/* Set semaphore value */
+
+	return i + 1;
+}
+
+
+static
+FRESULT dec_lock (	/* Decrement object open counter */
+	UINT i			/* Semaphore index (1..) */
+)
+{
+	WORD n;
+	FRESULT res;
+
+
+	if (--i < _FS_LOCK) {	/* Shift 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 */
+	}
+	return res;
+}
+
+
+static
+void clear_lock (	/* Clear lock entries of the volume */
+	FATFS *fs
+)
+{
+	UINT i;
+
+	for (i = 0; i < _FS_LOCK; i++) {
+		if (Files[i].fs == fs) Files[i].fs = 0;
+	}
+}
+
+#endif	/* _FS_LOCK != 0 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Move/Flush disk access window in the file system object               */
+/*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT sync_window (	/* Returns FR_OK or FR_DISK_ERROR */
+	FATFS* fs			/* File system object */
+)
+{
+	DWORD wsect;
+	UINT nf;
+	FRESULT res = FR_OK;
+
+
+	if (fs->wflag) {	/* Write back the sector if it is dirty */
+		wsect = fs->winsect;	/* Current sector number */
+		if (disk_write(fs->drv, fs->win, wsect, 1) != RES_OK) {
+			res = FR_DISK_ERR;
+		} else {
+			fs->wflag = 0;
+			if (wsect - fs->fatbase < fs->fsize) {		/* Is it in the FAT area? */
+				for (nf = fs->n_fats; nf >= 2; nf--) {	/* Reflect the change to all FAT copies */
+					wsect += fs->fsize;
+					disk_write(fs->drv, fs->win, wsect, 1);
+				}
+			}
+		}
+	}
+	return res;
+}
+#endif
+
+
+static
+FRESULT move_window (	/* Returns FR_OK or FR_DISK_ERROR */
+	FATFS* fs,			/* File system object */
+	DWORD sector		/* Sector number to make appearance in the fs->win[] */
+)
+{
+	FRESULT res = FR_OK;
+
+
+	if (sector != fs->winsect) {	/* Window offset changed? */
+#if !_FS_READONLY
+		res = sync_window(fs);		/* Write-back changes */
+#endif
+		if (res == FR_OK) {			/* Fill sector window with new data */
+			if (disk_read(fs->drv, fs->win, sector, 1) != RES_OK) {
+				sector = 0xFFFFFFFF;	/* Invalidate window if data is not reliable */
+				res = FR_DISK_ERR;
+			}
+			fs->winsect = sector;
+		}
+	}
+	return res;
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Synchronize file system and strage device                             */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT sync_fs (	/* FR_OK:succeeded, !=0:error */
+	FATFS* fs		/* File system object */
+)
+{
+	FRESULT res;
+
+
+	res = sync_window(fs);
+	if (res == FR_OK) {
+		/* Update FSInfo sector if needed */
+		if (fs->fs_type == FS_FAT32 && fs->fsi_flag == 1) {
+			/* Create FSInfo structure */
+			mem_set(fs->win, 0, SS(fs));
+			st_word(fs->win + BS_55AA, 0xAA55);
+			st_dword(fs->win + FSI_LeadSig, 0x41615252);
+			st_dword(fs->win + FSI_StrucSig, 0x61417272);
+			st_dword(fs->win + FSI_Free_Count, fs->free_clst);
+			st_dword(fs->win + FSI_Nxt_Free, fs->last_clst);
+			/* Write it into the FSInfo sector */
+			fs->winsect = fs->volbase + 1;
+			disk_write(fs->drv, fs->win, fs->winsect, 1);
+			fs->fsi_flag = 0;
+		}
+		/* Make sure that no pending write process in the physical drive */
+		if (disk_ioctl(fs->drv, CTRL_SYNC, 0) != RES_OK) res = FR_DISK_ERR;
+	}
+
+	return res;
+}
+
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get sector# from cluster#                                             */
+/*-----------------------------------------------------------------------*/
+
+static
+DWORD clust2sect (	/* !=0:Sector number, 0:Failed (invalid cluster#) */
+	FATFS* fs,		/* File system object */
+	DWORD clst		/* Cluster# to be converted */
+)
+{
+	clst -= 2;
+	if (clst >= fs->n_fatent - 2) return 0;		/* Invalid cluster# */
+	return clst * fs->csize + fs->database;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Read value of a FAT entry                                */
+/*-----------------------------------------------------------------------*/
+
+static
+DWORD get_fat (	/* 0xFFFFFFFF:Disk error, 1:Internal error, 2..0x7FFFFFFF:Cluster status */
+	_FDID* obj,	/* Corresponding object */
+	DWORD clst	/* Cluster number to get the value */
+)
+{
+	UINT wc, bc;
+	DWORD val;
+	FATFS *fs = obj->fs;
+
+
+	if (clst < 2 || clst >= fs->n_fatent) {	/* Check if in valid range */
+		val = 1;	/* Internal error */
+
+	} else {
+		val = 0xFFFFFFFF;	/* Default value falls on disk error */
+
+		switch (fs->fs_type) {
+		case FS_FAT12 :
+			bc = (UINT)clst; bc += bc / 2;
+			if (move_window(fs, fs->fatbase + (bc / SS(fs))) != FR_OK) break;
+			wc = fs->win[bc++ % SS(fs)];
+			if (move_window(fs, fs->fatbase + (bc / SS(fs))) != FR_OK) break;
+			wc |= fs->win[bc % SS(fs)] << 8;
+			val = (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
+			break;
+
+		case FS_FAT16 :
+			if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))) != FR_OK) break;
+			val = ld_word(fs->win + clst * 2 % SS(fs));
+			break;
+
+		case FS_FAT32 :
+			if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) != FR_OK) break;
+			val = ld_dword(fs->win + clst * 4 % SS(fs)) & 0x0FFFFFFF;
+			break;
+#if _FS_EXFAT
+		case FS_EXFAT :
+			if (obj->objsize) {
+				DWORD cofs = clst - obj->sclust;	/* Offset from start cluster */
+				DWORD clen = (DWORD)((obj->objsize - 1) / SS(fs)) / fs->csize;	/* Number of clusters - 1 */
+
+				if (obj->stat == 2) {	/* Is there no valid chain on the FAT? */
+					if (cofs <= clen) {
+						val = (cofs == clen) ? 0x7FFFFFFF : clst + 1;	/* Generate the value */
+						break;
+					}
+				}
+				if (obj->stat == 3 && cofs < obj->n_cont) {	/* Is it in the contiguous part? */
+					val = clst + 1; 	/* Generate the value */
+					break;
+				}
+				if (obj->stat != 2) {	/* Get value from FAT if FAT chain is valid */
+					if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) != FR_OK) break;
+					val = ld_dword(fs->win + clst * 4 % SS(fs)) & 0x7FFFFFFF;
+					break;
+				}
+			}
+			/* go next */
+#endif
+		default:
+			val = 1;	/* Internal error */
+		}
+	}
+
+	return val;
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* FAT access - Change value of a FAT entry                              */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT put_fat (	/* FR_OK(0):succeeded, !=0:error */
+	FATFS* fs,		/* Corresponding file system object */
+	DWORD clst,		/* FAT index number (cluster number) to be changed */
+	DWORD val		/* New value to be set to the entry */
+)
+{
+	UINT bc;
+	BYTE *p;
+	FRESULT res = FR_INT_ERR;
+
+
+	if (clst >= 2 && clst < fs->n_fatent) {	/* Check if in valid range */
+		switch (fs->fs_type) {
+		case FS_FAT12 :	/* Bitfield items */
+			bc = (UINT)clst; bc += bc / 2;
+			res = move_window(fs, fs->fatbase + (bc / SS(fs)));
+			if (res != FR_OK) break;
+			p = fs->win + bc++ % SS(fs);
+			*p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;
+			fs->wflag = 1;
+			res = move_window(fs, fs->fatbase + (bc / SS(fs)));
+			if (res != FR_OK) break;
+			p = fs->win + bc % SS(fs);
+			*p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
+			fs->wflag = 1;
+			break;
+
+		case FS_FAT16 :	/* WORD aligned items */
+			res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)));
+			if (res != FR_OK) break;
+			st_word(fs->win + clst * 2 % SS(fs), (WORD)val);
+			fs->wflag = 1;
+			break;
+
+		case FS_FAT32 :	/* DWORD aligned items */
+#if _FS_EXFAT
+		case FS_EXFAT :
+#endif
+			res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)));
+			if (res != FR_OK) break;
+			if (!_FS_EXFAT || fs->fs_type != FS_EXFAT) {
+				val = (val & 0x0FFFFFFF) | (ld_dword(fs->win + clst * 4 % SS(fs)) & 0xF0000000);
+			}
+			st_dword(fs->win + clst * 4 % SS(fs), val);
+			fs->wflag = 1;
+			break;
+		}
+	}
+	return res;
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+
+#if _FS_EXFAT && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* exFAT: Accessing FAT and Allocation Bitmap                            */
+/*-----------------------------------------------------------------------*/
+
+/*---------------------------------------------*/
+/* exFAT: Find a contiguous free cluster block */
+/*---------------------------------------------*/
+
+static
+DWORD find_bitmap (	/* 0:No free cluster, 2..:Free cluster found, 0xFFFFFFFF:Disk error */
+	FATFS* fs,	/* File system object */
+	DWORD clst,	/* Cluster number to scan from */
+	DWORD ncl	/* Number of contiguous clusters to find (1..) */
+)
+{
+	BYTE bm, bv;
+	UINT i;
+	DWORD val, scl, ctr;
+
+
+	clst -= 2;	/* The first bit in the bitmap corresponds to cluster #2 */
+	if (clst >= fs->n_fatent - 2) clst = 0;
+	scl = val = clst; ctr = 0;
+	for (;;) {
+		if (move_window(fs, fs->database + val / 8 / SS(fs)) != FR_OK) return 0xFFFFFFFF;
+		i = val / 8 % SS(fs); bm = 1 << (val % 8);
+		do {
+			do {
+				bv = fs->win[i] & bm; bm <<= 1;		/* Get bit value */
+				if (++val >= fs->n_fatent - 2) {	/* Next cluster (with wrap-around) */
+					val = 0; bm = 0; i = 4096;
+				}
+				if (!bv) {	/* Is it a free cluster? */
+					if (++ctr == ncl) return scl + 2;	/* Check run length */
+				} else {
+					scl = val; ctr = 0;		/* Encountered a live cluster, restart to scan */
+				}
+				if (val == clst) return 0;	/* All cluster scanned? */
+			} while (bm);
+			bm = 1;
+		} while (++i < SS(fs));
+	}
+}
+
+
+/*------------------------------------*/
+/* exFAT: Set/Clear a block of bitmap */
+/*------------------------------------*/
+
+static
+FRESULT change_bitmap (
+	FATFS* fs,	/* File system object */
+	DWORD clst,	/* Cluster number to change from */
+	DWORD ncl,	/* Number of clusters to be changed */
+	int bv		/* bit value to be set (0 or 1) */
+)
+{
+	BYTE bm;
+	UINT i;
+	DWORD sect;
+
+
+	clst -= 2;	/* The first bit corresponds to cluster #2 */
+	sect = fs->database + clst / 8 / SS(fs);	/* Sector address */
+	i = clst / 8 % SS(fs);						/* Byte offset in the sector */
+	bm = 1 << (clst % 8);						/* Bit mask in the byte */
+	for (;;) {
+		if (move_window(fs, sect++) != FR_OK) return FR_DISK_ERR;
+		do {
+			do {
+				if (bv == (int)((fs->win[i] & bm) != 0)) return FR_INT_ERR;	/* Is the bit expected value? */
+				fs->win[i] ^= bm;	/* Flip the bit */
+				fs->wflag = 1;
+				if (--ncl == 0) return FR_OK;	/* All bits processed? */
+			} while (bm <<= 1);		/* Next bit */
+			bm = 1;
+		} while (++i < SS(fs));		/* Next byte */
+		i = 0;
+	}
+}
+
+
+/*---------------------------------------------*/
+/* Complement contiguous part of the FAT chain */
+/*---------------------------------------------*/
+
+static
+FRESULT fill_fat_chain (
+	_FDID* obj	/* Pointer to the corresponding object */
+)
+{
+	FRESULT res;
+	DWORD cl, n;
+
+	if (obj->stat == 3) {	/* Has the object been changed 'fragmented'? */
+		for (cl = obj->sclust, n = obj->n_cont; n; cl++, n--) {	/* Create cluster chain on the FAT */
+			res = put_fat(obj->fs, cl, cl + 1);
+			if (res != FR_OK) return res;
+		}
+		obj->stat = 0;	/* Change status 'FAT chain is valid' */
+	}
+	return FR_OK;
+}
+
+#endif	/* _FS_EXFAT && !_FS_READONLY */
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Remove a cluster chain                                 */
+/*-----------------------------------------------------------------------*/
+static
+FRESULT remove_chain (	/* FR_OK(0):succeeded, !=0:error */
+	_FDID* obj,			/* Corresponding object */
+	DWORD clst,			/* Cluster to remove a chain from */
+	DWORD pclst			/* Previous cluster of clst (0:an entire chain) */
+)
+{
+	FRESULT res = FR_OK;
+	DWORD nxt;
+	FATFS *fs = obj->fs;
+#if _FS_EXFAT || _USE_TRIM
+	DWORD scl = clst, ecl = clst;
+#endif
+#if _USE_TRIM
+	DWORD rt[2];
+#endif
+
+	if (clst < 2 || clst >= fs->n_fatent) return FR_INT_ERR;	/* Check if in valid range */
+
+	/* Mark the previous cluster 'EOC' on the FAT if it exists */
+	if (pclst && (!_FS_EXFAT || fs->fs_type != FS_EXFAT || obj->stat != 2)) {
+		res = put_fat(fs, pclst, 0xFFFFFFFF);
+		if (res != FR_OK) return res;
+	}
+
+	/* Remove the chain */
+	do {
+		nxt = get_fat(obj, clst);			/* Get cluster status */
+		if (nxt == 0) break;				/* Empty cluster? */
+		if (nxt == 1) return FR_INT_ERR;	/* Internal error? */
+		if (nxt == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error? */
+		if (!_FS_EXFAT || fs->fs_type != FS_EXFAT) {
+			res = put_fat(fs, clst, 0);		/* Mark the cluster 'free' on the FAT */
+			if (res != FR_OK) return res;
+		}
+		if (fs->free_clst < fs->n_fatent - 2) {	/* Update FSINFO */
+			fs->free_clst++;
+			fs->fsi_flag |= 1;
+		}
+#if _FS_EXFAT || _USE_TRIM
+		if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+			ecl = nxt;
+		} else {				/* End of contiguous cluster block */ 
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				res = change_bitmap(fs, scl, ecl - scl + 1, 0);	/* Mark the cluster block 'free' on the bitmap */
+				if (res != FR_OK) return res;
+			}
+#endif
+#if _USE_TRIM
+			rt[0] = clust2sect(fs, scl);					/* Start sector */
+			rt[1] = clust2sect(fs, ecl) + fs->csize - 1;	/* End sector */
+			disk_ioctl(fs->drv, CTRL_TRIM, rt);				/* Inform device the block can be erased */
+#endif
+			scl = ecl = nxt;
+		}
+#endif
+		clst = nxt;					/* Next cluster */
+	} while (clst < fs->n_fatent);	/* Repeat while not the last link */
+
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {
+		if (pclst == 0) {	/* Does object have no chain? */
+			obj->stat = 0;		/* Change the object status 'initial' */
+		} else {
+			if (obj->stat == 3 && pclst >= obj->sclust && pclst <= obj->sclust + obj->n_cont) {	/* Did the chain got contiguous? */
+				obj->stat = 2;	/* Change the object status 'contiguous' */
+			}
+		}
+	}
+#endif
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Stretch a chain or Create a new chain                  */
+/*-----------------------------------------------------------------------*/
+static
+DWORD create_chain (	/* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */
+	_FDID* obj,			/* Corresponding object */
+	DWORD clst			/* Cluster# to stretch, 0:Create a new chain */
+)
+{
+	DWORD cs, ncl, scl;
+	FRESULT res;
+	FATFS *fs = obj->fs;
+
+
+	if (clst == 0) {	/* Create a new chain */
+		scl = fs->last_clst;				/* Get suggested cluster to start at */
+		if (scl == 0 || scl >= fs->n_fatent) scl = 1;
+	}
+	else {				/* Stretch current chain */
+		cs = get_fat(obj, clst);			/* Check the cluster status */
+		if (cs < 2) return 1;				/* Invalid value */
+		if (cs == 0xFFFFFFFF) return cs;	/* A disk error occurred */
+		if (cs < fs->n_fatent) return cs;	/* It is already followed by next cluster */
+		scl = clst;
+	}
+
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+		ncl = find_bitmap(fs, scl, 1);				/* Find a free cluster */
+		if (ncl == 0 || ncl == 0xFFFFFFFF) return ncl;	/* No free cluster or hard error? */
+		res = change_bitmap(fs, ncl, 1, 1);			/* Mark the cluster 'in use' */
+		if (res == FR_INT_ERR) return 1;
+		if (res == FR_DISK_ERR) return 0xFFFFFFFF;
+		if (clst == 0) {							/* Is it a new chain? */
+			obj->stat = 2;							/* Set status 'contiguous chain' */
+		} else {									/* This is a stretched chain */
+			if (obj->stat == 2 && ncl != scl + 1) {	/* Is the chain got fragmented? */
+				obj->n_cont = scl - obj->sclust;	/* Set size of the contiguous part */
+				obj->stat = 3;						/* Change status 'just fragmented' */
+			}
+		}
+	} else
+#endif
+	{	/* At the FAT12/16/32 */
+		ncl = scl;	/* Start cluster */
+		for (;;) {
+			ncl++;							/* Next cluster */
+			if (ncl >= fs->n_fatent) {		/* Check wrap-around */
+				ncl = 2;
+				if (ncl > scl) return 0;	/* No free cluster */
+			}
+			cs = get_fat(obj, ncl);			/* Get the cluster status */
+			if (cs == 0) break;				/* Found a free cluster */
+			if (cs == 1 || cs == 0xFFFFFFFF) return cs;	/* An error occurred */
+			if (ncl == scl) return 0;		/* No free cluster */
+		}
+	}
+
+	if (_FS_EXFAT && fs->fs_type == FS_EXFAT && obj->stat == 2) {	/* Is it a contiguous chain? */
+		res = FR_OK;						/* FAT does not need to be written */
+	} else {
+		res = put_fat(fs, ncl, 0xFFFFFFFF);	/* Mark the new cluster 'EOC' */
+		if (res == FR_OK && clst) {
+			res = put_fat(fs, clst, ncl);	/* Link it from the previous one if needed */
+		}
+	}
+
+	if (res == FR_OK) {			/* Update FSINFO if function succeeded. */
+		fs->last_clst = ncl;
+		if (fs->free_clst < fs->n_fatent - 2) fs->free_clst--;
+		fs->fsi_flag |= 1;
+	} else {
+		ncl = (res == FR_DISK_ERR) ? 0xFFFFFFFF : 1;	/* Failed. Create error status */
+	}
+
+	return ncl;		/* Return new cluster number or error status */
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+
+#if _USE_FASTSEEK
+/*-----------------------------------------------------------------------*/
+/* FAT handling - Convert offset into cluster with link map table        */
+/*-----------------------------------------------------------------------*/
+
+static
+DWORD clmt_clust (	/* <2:Error, >=2:Cluster number */
+	FIL* fp,		/* Pointer to the file object */
+	FSIZE_t ofs		/* File offset to be converted to cluster# */
+)
+{
+	DWORD cl, ncl, *tbl;
+	FATFS *fs = fp->obj.fs;
+
+
+	tbl = fp->cltbl + 1;	/* Top of CLMT */
+	cl = (DWORD)(ofs / SS(fs) / fs->csize);	/* Cluster order from top of the file */
+	for (;;) {
+		ncl = *tbl++;			/* Number of cluters in the fragment */
+		if (ncl == 0) return 0;	/* End of table? (error) */
+		if (cl < ncl) break;	/* In this fragment? */
+		cl -= ncl; tbl++;		/* Next fragment */
+	}
+	return cl + *tbl;	/* Return the cluster number */
+}
+
+#endif	/* _USE_FASTSEEK */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Set directory index                              */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_sdi (	/* FR_OK(0):succeeded, !=0:error */
+	DIR* dp,		/* Pointer to directory object */
+	DWORD ofs		/* Offset of directory table */
+)
+{
+	DWORD csz, clst;
+	FATFS *fs = dp->obj.fs;
+
+
+	if (ofs >= (DWORD)((_FS_EXFAT && fs->fs_type == FS_EXFAT) ? MAX_DIR_EX : MAX_DIR) || ofs % SZDIRE) {	/* Check range of offset and alignment */
+		return FR_INT_ERR;
+	}
+	dp->dptr = ofs;				/* Set current offset */
+	clst = dp->obj.sclust;		/* Table start cluster (0:root) */
+	if (clst == 0 && fs->fs_type >= FS_FAT32) {	/* Replace cluster# 0 with root cluster# */
+		clst = fs->dirbase;
+		if (_FS_EXFAT) dp->obj.stat = 0;	/* exFAT: Root dir has an FAT chain */
+	}
+
+	if (clst == 0) {	/* Static table (root-directory in FAT12/16) */
+		if (ofs / SZDIRE >= fs->n_rootdir)	return FR_INT_ERR;	/* Is index out of range? */
+		dp->sect = fs->dirbase;
+
+	} else {			/* Dynamic table (sub-directory or root-directory in FAT32+) */
+		csz = (DWORD)fs->csize * SS(fs);	/* Bytes per cluster */
+		while (ofs >= csz) {				/* Follow cluster chain */
+			clst = get_fat(&dp->obj, clst);				/* Get next cluster */
+			if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */
+			if (clst < 2 || clst >= fs->n_fatent) return FR_INT_ERR;	/* Reached to end of table or internal error */
+			ofs -= csz;
+		}
+		dp->sect = clust2sect(fs, clst);
+	}
+	dp->clust = clst;					/* Current cluster# */
+	if (!dp->sect) return FR_INT_ERR;
+	dp->sect += ofs / SS(fs);			/* Sector# of the directory entry */
+	dp->dir = fs->win + (ofs % SS(fs));	/* Pointer to the entry in the win[] */
+
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Move directory table index next                  */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_next (	/* FR_OK(0):succeeded, FR_NO_FILE:End of table, FR_DENIED:Could not stretch */
+	DIR* dp,		/* Pointer to the directory object */
+	int stretch		/* 0: Do not stretch table, 1: Stretch table if needed */
+)
+{
+	DWORD ofs, clst;
+	FATFS *fs = dp->obj.fs;
+#if !_FS_READONLY
+	UINT n;
+#endif
+
+	ofs = dp->dptr + SZDIRE;	/* Next entry */
+	if (!dp->sect || ofs >= (DWORD)((_FS_EXFAT && fs->fs_type == FS_EXFAT) ? MAX_DIR_EX : MAX_DIR)) return FR_NO_FILE;	/* Report EOT when offset has reached max value */
+
+	if (ofs % SS(fs) == 0) {	/* Sector changed? */
+		dp->sect++;				/* Next sector */
+
+		if (!dp->clust) {		/* Static table */
+			if (ofs / SZDIRE >= fs->n_rootdir) {	/* Report EOT if it reached end of static table */
+				dp->sect = 0; return FR_NO_FILE;
+			}
+		}
+		else {					/* Dynamic table */
+			if ((ofs / SS(fs) & (fs->csize - 1)) == 0) {		/* Cluster changed? */
+				clst = get_fat(&dp->obj, dp->clust);			/* Get next cluster */
+				if (clst <= 1) return FR_INT_ERR;				/* Internal error */
+				if (clst == 0xFFFFFFFF) return FR_DISK_ERR;		/* Disk error */
+				if (clst >= fs->n_fatent) {						/* Reached end of dynamic table */
+#if !_FS_READONLY
+					if (!stretch) {								/* If no stretch, report EOT */
+						dp->sect = 0; return FR_NO_FILE;
+					}
+					clst = create_chain(&dp->obj, dp->clust);	/* Allocate a cluster */
+					if (clst == 0) return FR_DENIED;			/* No free cluster */
+					if (clst == 1) return FR_INT_ERR;			/* Internal error */
+					if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */
+					/* Clean-up the stretched table */
+					if (_FS_EXFAT) dp->obj.stat |= 4;			/* The directory needs to be updated */
+					if (sync_window(fs) != FR_OK) return FR_DISK_ERR;	/* Flush disk access window */
+					mem_set(fs->win, 0, SS(fs));				/* Clear window buffer */
+					for (n = 0, fs->winsect = clust2sect(fs, clst); n < fs->csize; n++, fs->winsect++) {	/* Fill the new cluster with 0 */
+						fs->wflag = 1;
+						if (sync_window(fs) != FR_OK) return FR_DISK_ERR;
+					}
+					fs->winsect -= n;							/* Restore window offset */
+#else
+					if (!stretch) dp->sect = 0;					/* If no stretch, report EOT (this is to suppress warning) */
+					dp->sect = 0; return FR_NO_FILE;			/* Report EOT */
+#endif
+				}
+				dp->clust = clst;		/* Initialize data for new cluster */
+				dp->sect = clust2sect(fs, clst);
+			}
+		}
+	}
+	dp->dptr = ofs;						/* Current entry */
+	dp->dir = fs->win + ofs % SS(fs);	/* Pointer to the entry in the win[] */
+
+	return FR_OK;
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Reserve a block of directory entries             */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_alloc (	/* FR_OK(0):succeeded, !=0:error */
+	DIR* dp,		/* Pointer to the directory object */
+	UINT nent		/* Number of contiguous entries to allocate */
+)
+{
+	FRESULT res;
+	UINT n;
+	FATFS *fs = dp->obj.fs;
+
+
+	res = dir_sdi(dp, 0);
+	if (res == FR_OK) {
+		n = 0;
+		do {
+			res = move_window(fs, dp->sect);
+			if (res != FR_OK) break;
+#if _FS_EXFAT
+			if ((fs->fs_type == FS_EXFAT) ? (int)((dp->dir[XDIR_Type] & 0x80) == 0) : (int)(dp->dir[DIR_Name] == DDEM || dp->dir[DIR_Name] == 0)) {
+#else
+			if (dp->dir[DIR_Name] == DDEM || dp->dir[DIR_Name] == 0) {
+#endif
+				if (++n == nent) break;	/* A block of contiguous free entries is found */
+			} else {
+				n = 0;					/* Not a blank entry. Restart to search */
+			}
+			res = dir_next(dp, 1);
+		} while (res == FR_OK);	/* Next entry with table stretch enabled */
+	}
+
+	if (res == FR_NO_FILE) res = FR_DENIED;	/* No directory entry to allocate */
+	return res;
+}
+
+#endif	/* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT: Directory handling - Load/Store start cluster number             */
+/*-----------------------------------------------------------------------*/
+
+static
+DWORD ld_clust (	/* Returns the top cluster value of the SFN entry */
+	FATFS* fs,		/* Pointer to the fs object */
+	const BYTE* dir	/* Pointer to the key entry */
+)
+{
+	DWORD cl;
+
+	cl = ld_word(dir + DIR_FstClusLO);
+	if (fs->fs_type == FS_FAT32) {
+		cl |= (DWORD)ld_word(dir + DIR_FstClusHI) << 16;
+	}
+
+	return cl;
+}
+
+
+#if !_FS_READONLY
+static
+void st_clust (
+	FATFS* fs,	/* Pointer to the fs object */
+	BYTE* dir,	/* Pointer to the key entry */
+	DWORD cl	/* Value to be set */
+)
+{
+	st_word(dir + DIR_FstClusLO, (WORD)cl);
+	if (fs->fs_type == FS_FAT32) {
+		st_word(dir + DIR_FstClusHI, (WORD)(cl >> 16));
+	}
+}
+#endif
+
+
+
+#if _USE_LFN != 0
+/*------------------------------------------------------------------------*/
+/* FAT-LFN: LFN handling                                                  */
+/*------------------------------------------------------------------------*/
+static
+const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};	/* Offset of LFN characters in the directory entry */
+
+
+/*--------------------------------------------------------*/
+/* FAT-LFN: Compare a part of file name with an LFN entry */
+/*--------------------------------------------------------*/
+static
+int cmp_lfn (				/* 1:matched, 0:not matched */
+	const WCHAR* lfnbuf,	/* Pointer to the LFN working buffer to be compared */
+	BYTE* dir				/* Pointer to the directory entry containing the part of LFN */
+)
+{
+	UINT i, s;
+	WCHAR wc, uc;
+
+
+	if (ld_word(dir + LDIR_FstClusLO) != 0) return 0;	/* Check LDIR_FstClusLO */
+
+	i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;	/* Offset in the LFN buffer */
+
+	for (wc = 1, s = 0; s < 13; s++) {		/* Process all characters in the entry */
+		uc = ld_word(dir + LfnOfs[s]);		/* Pick an LFN character */
+		if (wc) {
+			if (i >= _MAX_LFN || ff_wtoupper(uc) != ff_wtoupper(lfnbuf[i++])) {	/* Compare it */
+				return 0;					/* Not matched */
+			}
+			wc = uc;
+		} else {
+			if (uc != 0xFFFF) return 0;		/* Check filler */
+		}
+	}
+
+	if ((dir[LDIR_Ord] & LLEF) && wc && lfnbuf[i]) return 0;	/* Last segment matched but different length */
+
+	return 1;		/* The part of LFN matched */
+}
+
+
+#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2 || _USE_LABEL || _FS_EXFAT
+/*-----------------------------------------------------*/
+/* FAT-LFN: Pick a part of file name from an LFN entry */
+/*-----------------------------------------------------*/
+static
+int pick_lfn (			/* 1:succeeded, 0:buffer overflow or invalid LFN entry */
+	WCHAR* lfnbuf,		/* Pointer to the LFN working buffer */
+	BYTE* dir			/* Pointer to the LFN entry */
+)
+{
+	UINT i, s;
+	WCHAR wc, uc;
+
+
+	if (ld_word(dir + LDIR_FstClusLO) != 0) return 0;	/* Check LDIR_FstClusLO */
+
+	i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;	/* Offset in the LFN buffer */
+
+	for (wc = 1, s = 0; s < 13; s++) {		/* Process all characters in the entry */
+		uc = ld_word(dir + LfnOfs[s]);		/* Pick an LFN character */
+		if (wc) {
+			if (i >= _MAX_LFN) return 0;	/* Buffer overflow? */
+			lfnbuf[i++] = wc = uc;			/* Store it */
+		} else {
+			if (uc != 0xFFFF) return 0;		/* Check filler */
+		}
+	}
+
+	if (dir[LDIR_Ord] & LLEF) {				/* Put terminator if it is the last LFN part */
+		if (i >= _MAX_LFN) return 0;		/* Buffer overflow? */
+		lfnbuf[i] = 0;
+	}
+
+	return 1;		/* The part of LFN is valid */
+}
+#endif
+
+
+#if !_FS_READONLY
+/*-----------------------------------------*/
+/* FAT-LFN: Create an entry of LFN entries */
+/*-----------------------------------------*/
+static
+void put_lfn (
+	const WCHAR* lfn,	/* Pointer to the LFN */
+	BYTE* dir,			/* Pointer to the LFN entry to be created */
+	BYTE ord,			/* LFN order (1-20) */
+	BYTE sum			/* Checksum of the corresponding SFN */
+)
+{
+	UINT i, s;
+	WCHAR wc;
+
+
+	dir[LDIR_Chksum] = sum;			/* Set checksum */
+	dir[LDIR_Attr] = AM_LFN;		/* Set attribute. LFN entry */
+	dir[LDIR_Type] = 0;
+	st_word(dir + LDIR_FstClusLO, 0);
+
+	i = (ord - 1) * 13;				/* Get offset in the LFN working buffer */
+	s = wc = 0;
+	do {
+		if (wc != 0xFFFF) wc = lfn[i++];	/* Get an effective character */
+		st_word(dir + LfnOfs[s], wc);		/* Put it */
+		if (wc == 0) wc = 0xFFFF;		/* Padding characters for left locations */
+	} while (++s < 13);
+	if (wc == 0xFFFF || !lfn[i]) ord |= LLEF;	/* Last LFN part is the start of LFN sequence */
+	dir[LDIR_Ord] = ord;			/* Set the LFN order */
+}
+
+#endif	/* !_FS_READONLY */
+#endif	/* _USE_LFN != 0 */
+
+
+
+#if _USE_LFN != 0 && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* FAT-LFN: Create a Numbered SFN                                        */
+/*-----------------------------------------------------------------------*/
+
+static
+void gen_numname (
+	BYTE* dst,			/* Pointer to the buffer to store numbered SFN */
+	const BYTE* src,	/* Pointer to SFN */
+	const WCHAR* lfn,	/* Pointer to LFN */
+	UINT seq			/* Sequence number */
+)
+{
+	BYTE ns[8], c;
+	UINT i, j;
+	WCHAR wc;
+	DWORD sr;
+
+
+	mem_cpy(dst, src, 11);
+
+	if (seq > 5) {	/* In case of many collisions, generate a hash number instead of sequential number */
+		sr = seq;
+		while (*lfn) {	/* Create a CRC */
+			wc = *lfn++;
+			for (i = 0; i < 16; i++) {
+				sr = (sr << 1) + (wc & 1);
+				wc >>= 1;
+				if (sr & 0x10000) sr ^= 0x11021;
+			}
+		}
+		seq = (UINT)sr;
+	}
+
+	/* itoa (hexdecimal) */
+	i = 7;
+	do {
+		c = (seq % 16) + '0';
+		if (c > '9') c += 7;
+		ns[i--] = c;
+		seq /= 16;
+	} while (seq);
+	ns[i] = '~';
+
+	/* Append the number */
+	for (j = 0; j < i && dst[j] != ' '; j++) {
+		if (IsDBCS1(dst[j])) {
+			if (j == i - 1) break;
+			j++;
+		}
+	}
+	do {
+		dst[j++] = (i < 8) ? ns[i++] : ' ';
+	} while (j < 8);
+}
+#endif	/* _USE_LFN != 0 && !_FS_READONLY */
+
+
+
+#if _USE_LFN != 0
+/*-----------------------------------------------------------------------*/
+/* FAT-LFN: Calculate checksum of an SFN entry                           */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE sum_sfn (
+	const BYTE* dir		/* Pointer to the SFN entry */
+)
+{
+	BYTE sum = 0;
+	UINT n = 11;
+
+	do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);
+	return sum;
+}
+
+#endif	/* _USE_LFN != 0 */
+
+
+
+#if _FS_EXFAT
+/*-----------------------------------------------------------------------*/
+/* exFAT: Checksum                                                       */
+/*-----------------------------------------------------------------------*/
+
+static
+WORD xdir_sum (			/* Get checksum of the directoly block */
+	const BYTE* dir		/* Directory entry block to be calculated */
+)
+{
+	UINT i, szblk;
+	WORD sum;
+
+
+	szblk = (dir[XDIR_NumSec] + 1) * SZDIRE;
+	for (i = sum = 0; i < szblk; i++) {
+		if (i == XDIR_SetSum) {	/* Skip sum field */
+			i++;
+		} else {
+			sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + dir[i];
+		}
+	}
+	return sum;
+}
+
+
+
+static
+WORD xname_sum (		/* Get check sum (to be used as hash) of the name */
+	const WCHAR* name	/* File name to be calculated */
+)
+{
+	WCHAR chr;
+	WORD sum = 0;
+
+
+	while ((chr = *name++) != 0) {
+		chr = ff_wtoupper(chr);		/* File name needs to be ignored case */
+		sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + (chr & 0xFF);
+		sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + (chr >> 8);
+	}
+	return sum;
+}
+
+
+#if !_FS_READONLY && _USE_MKFS
+static
+DWORD xsum32 (
+	BYTE  dat,	/* Data to be sumed */
+	DWORD sum	/* Previous value */
+)
+{
+	sum = ((sum & 1) ? 0x80000000 : 0) + (sum >> 1) + dat;
+	return sum;
+}
+#endif
+
+
+#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2
+/*------------------------------------------------------*/
+/* exFAT: Get object information from a directory block */
+/*------------------------------------------------------*/
+
+static
+void get_xdir_info (
+	BYTE* dirb,			/* Pointer to the direcotry entry block 85+C0+C1s */
+	FILINFO* fno		/* Buffer to store the extracted file information */
+)
+{
+	UINT di, si;
+	WCHAR w;
+#if !_LFN_UNICODE
+	UINT nc;
+#endif
+
+	/* Get file name */
+#if _LFN_UNICODE
+	if (dirb[XDIR_NumName] <= _MAX_LFN) {
+		for (si = SZDIRE * 2, di = 0; di < dirb[XDIR_NumName]; si += 2, di++) {
+			if ((si % SZDIRE) == 0) si += 2;	/* Skip entry type field */
+			w = ld_word(dirb + si);				/* Get a character */
+			fno->fname[di] = w;					/* Store it */
+		}
+	} else {
+		di = 0;	/* Buffer overflow and inaccessible object */
+	}
+#else
+	for (si = SZDIRE * 2, di = nc = 0; nc < dirb[XDIR_NumName]; si += 2, nc++) {
+		if ((si % SZDIRE) == 0) si += 2;	/* Skip entry type field */
+		w = ld_word(dirb + si);				/* Get a character */
+		w = ff_convert(w, 0);				/* Unicode -> OEM */
+		if (w == 0) { di = 0; break; }		/* Could not be converted and inaccessible object */
+		if (_DF1S && w >= 0x100) {			/* Put 1st byte if it is a DBC (always false at SBCS cfg) */
+			fno->fname[di++] = (char)(w >> 8);
+		}
+		if (di >= _MAX_LFN) { di = 0; break; }	/* Buffer overflow and inaccessible object */
+		fno->fname[di++] = (char)w;
+	}
+#endif
+	if (di == 0) fno->fname[di++] = '?';	/* Inaccessible object? */
+	fno->fname[di] = 0;						/* Terminate file name */
+
+	fno->altname[0] = 0;							/* No SFN */
+	fno->fattrib = dirb[XDIR_Attr];					/* Attribute */
+	fno->fsize = (fno->fattrib & AM_DIR) ? 0 : ld_qword(dirb + XDIR_FileSize);	/* Size */
+	fno->ftime = ld_word(dirb + XDIR_ModTime + 0);	/* Time */
+	fno->fdate = ld_word(dirb + XDIR_ModTime + 2);	/* Date */
+}
+
+#endif	/* _FS_MINIMIZE <= 1 || _FS_RPATH >= 2 */
+
+
+/*-----------------------------------*/
+/* exFAT: Get a directry entry block */
+/*-----------------------------------*/
+
+static
+FRESULT load_xdir (	/* FR_INT_ERR: invalid entry block */
+	DIR* dp			/* Pointer to the reading direcotry object pointing the 85 entry */
+)
+{
+	FRESULT res;
+	UINT i, nent;
+	BYTE* dirb = dp->obj.fs->dirbuf;	/* Pointer to the on-memory direcotry entry block 85+C0+C1s */
+
+
+	/* Load 85 entry */
+	res = move_window(dp->obj.fs, dp->sect);
+	if (res != FR_OK) return res;
+	if (dp->dir[XDIR_Type] != 0x85) return FR_INT_ERR;
+	mem_cpy(dirb, dp->dir, SZDIRE);
+	nent = dirb[XDIR_NumSec] + 1;
+
+	/* Load C0 entry */
+	res = dir_next(dp, 0);
+	if (res != FR_OK) return res;
+	res = move_window(dp->obj.fs, dp->sect);
+	if (res != FR_OK) return res;
+	if (dp->dir[XDIR_Type] != 0xC0) return FR_INT_ERR;
+	mem_cpy(dirb + SZDIRE, dp->dir, SZDIRE);
+
+	/* Load C1 entries */
+	if (nent < 3 || nent > 19) return FR_NO_FILE;
+	i = SZDIRE * 2; nent *= SZDIRE;
+	do {
+		res = dir_next(dp, 0);
+		if (res != FR_OK) return res;
+		res = move_window(dp->obj.fs, dp->sect);
+		if (res != FR_OK) return res;
+		if (dp->dir[XDIR_Type] != 0xC1) return FR_INT_ERR;
+		mem_cpy(dirb + i, dp->dir, SZDIRE);
+		i += SZDIRE;
+	} while (i < nent);
+
+	/* Sanity check */
+	if (xdir_sum(dirb) != ld_word(dirb + XDIR_SetSum)) return FR_INT_ERR;
+
+	return FR_OK;
+}
+
+
+#if !_FS_READONLY || _FS_RPATH != 0 
+/*------------------------------------------------*/
+/* exFAT: Load the object's directory entry block */
+/*------------------------------------------------*/
+static
+FRESULT load_obj_dir (	
+	DIR* dp,			/* Blank directory object to be used to access containing direcotry */
+	const _FDID* obj	/* Object with containing directory information */
+)
+{
+	FRESULT res;
+
+
+	/* Open object containing directory */
+	dp->obj.fs = obj->fs;
+	dp->obj.sclust = obj->c_scl;
+	dp->obj.stat = (BYTE)obj->c_size;
+	dp->obj.objsize = obj->c_size & 0xFFFFFF00;
+	dp->blk_ofs = obj->c_ofs;
+
+	res = dir_sdi(dp, dp->blk_ofs);	/* Goto the block location */
+	if (res == FR_OK) {
+		res = load_xdir(dp);		/* Load the object's entry block */
+	}
+	return res;
+}
+#endif
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------*/
+/* exFAT: Store the directory block to the media */
+/*-----------------------------------------------*/
+static
+FRESULT store_xdir (
+	DIR* dp				/* Pointer to the direcotry object */
+)
+{
+	FRESULT res;
+	UINT nent;
+	BYTE* dirb = dp->obj.fs->dirbuf;	/* Pointer to the direcotry entry block 85+C0+C1s */
+
+	/* Create set sum */
+	st_word(dirb + XDIR_SetSum, xdir_sum(dirb));
+	nent = dirb[XDIR_NumSec] + 1;
+
+	/* Store the set of directory to the volume */
+	res = dir_sdi(dp, dp->blk_ofs);
+	while (res == FR_OK) {
+		res = move_window(dp->obj.fs, dp->sect);
+		if (res != FR_OK) break;
+		mem_cpy(dp->dir, dirb, SZDIRE);
+		dp->obj.fs->wflag = 1;
+		if (--nent == 0) break;
+		dirb += SZDIRE;
+		res = dir_next(dp, 0);
+	}
+	return (res == FR_OK || res == FR_DISK_ERR) ? res : FR_INT_ERR;
+}
+
+
+
+/*-------------------------------------------*/
+/* exFAT: Create a new directory enrty block */
+/*-------------------------------------------*/
+
+static
+void create_xdir (
+	BYTE* dirb,			/* Pointer to the direcotry entry block buffer */
+	const WCHAR* lfn	/* Pointer to the nul terminated file name */
+)
+{
+	UINT i;
+	BYTE nb, nc;
+	WCHAR chr;
+
+
+	mem_set(dirb, 0, 2 * SZDIRE);			/* Initialize 85+C0 entry */
+	dirb[XDIR_Type] = 0x85;
+	dirb[XDIR_Type + SZDIRE] = 0xC0;
+	st_word(dirb + XDIR_NameHash, xname_sum(lfn));	/* Set name hash */
+
+	i = SZDIRE * 2;	/* C1 offset */
+	nc = 0; nb = 1; chr = 1;
+	do {
+		dirb[i++] = 0xC1; dirb[i++] = 0;	/* Entry type C1 */
+		do {	/* Fill name field */
+			if (chr && (chr = lfn[nc]) != 0) nc++;	/* Get a character if exist */
+			st_word(dirb + i, chr); i += 2;	/* Store it */
+		} while (i % SZDIRE);
+		nb++;
+	} while (lfn[nc]);	/* Fill next entry if any char follows */
+
+	dirb[XDIR_NumName] = nc;	/* Set name length */
+	dirb[XDIR_NumSec] = nb;		/* Set number of C0+C1s */
+}
+
+#endif	/* !_FS_READONLY */
+#endif	/* _FS_EXFAT */
+
+
+
+#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2 || _USE_LABEL || _FS_EXFAT
+/*-----------------------------------------------------------------------*/
+/* Read an object from the directory                                     */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_read (
+	DIR* dp,		/* Pointer to the directory object */
+	int vol			/* Filtered by 0:file/directory or 1:volume label */
+)
+{
+	FRESULT res = FR_NO_FILE;
+	FATFS *fs = dp->obj.fs;
+	BYTE a, c;
+#if _USE_LFN != 0
+	BYTE ord = 0xFF, sum = 0xFF;
+#endif
+
+	while (dp->sect) {
+		res = move_window(fs, dp->sect);
+		if (res != FR_OK) break;
+		c = dp->dir[DIR_Name];	/* Test for the entry type */
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of the directory */
+#if _FS_EXFAT
+		if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+			if (_USE_LABEL && vol) {
+				if (c == 0x83) break;	/* Volume label entry? */
+			} else {
+				if (c == 0x85) {		/* Start of the file entry block? */
+					dp->blk_ofs = dp->dptr;	/* Get location of the block */
+					res = load_xdir(dp);	/* Load the entry block */
+					if (res == FR_OK) {
+						dp->obj.attr = fs->dirbuf[XDIR_Attr] & AM_MASK;	/* Get attribute */
+					}
+					break;
+				}
+			}
+		} else
+#endif
+		{	/* At the FAT12/16/32 */
+			dp->obj.attr = a = dp->dir[DIR_Attr] & AM_MASK;	/* Get attribute */
+#if _USE_LFN != 0	/* LFN configuration */
+			if (c == DDEM || c == '.' || (int)((a & ~AM_ARC) == AM_VOL) != vol) {	/* An entry without valid data */
+				ord = 0xFF;
+			} else {
+				if (a == AM_LFN) {			/* An LFN entry is found */
+					if (c & LLEF) {			/* Is it start of an LFN sequence? */
+						sum = dp->dir[LDIR_Chksum];
+						c &= ~LLEF; ord = c;
+						dp->blk_ofs = dp->dptr;
+					}
+					/* Check LFN validity and capture it */
+					ord = (c == ord && sum == dp->dir[LDIR_Chksum] && pick_lfn(fs->lfnbuf, dp->dir)) ? ord - 1 : 0xFF;
+				} else {					/* An SFN entry is found */
+					if (ord || sum != sum_sfn(dp->dir)) {	/* Is there a valid LFN? */
+						dp->blk_ofs = 0xFFFFFFFF;			/* It has no LFN. */
+					}
+					break;
+				}
+			}
+#else		/* Non LFN configuration */
+			if (c != DDEM && c != '.' && a != AM_LFN && (int)((a & ~AM_ARC) == AM_VOL) == vol) {	/* Is it a valid entry? */
+				break;
+			}
+#endif
+		}
+		res = dir_next(dp, 0);		/* Next entry */
+		if (res != FR_OK) break;
+	}
+
+	if (res != FR_OK) dp->sect = 0;		/* Terminate the read operation on error or EOT */
+	return res;
+}
+
+#endif	/* _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Find an object in the directory                  */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_find (	/* FR_OK(0):succeeded, !=0:error */
+	DIR* dp			/* Pointer to the directory object with the file name */
+)
+{
+	FRESULT res;
+	FATFS *fs = dp->obj.fs;
+	BYTE c;
+#if _USE_LFN != 0
+	BYTE a, ord, sum;
+#endif
+
+	res = dir_sdi(dp, 0);			/* Rewind directory object */
+	if (res != FR_OK) return res;
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+		BYTE nc;
+		UINT di, ni;
+		WORD hash = xname_sum(fs->lfnbuf);		/* Hash value of the name to find */
+
+		while ((res = dir_read(dp, 0)) == FR_OK) {	/* Read an item */
+			if (ld_word(fs->dirbuf + XDIR_NameHash) != hash) continue;	/* Skip the comparison if hash value mismatched */
+			for (nc = fs->dirbuf[XDIR_NumName], di = SZDIRE * 2, ni = 0; nc; nc--, di += 2, ni++) {	/* Compare the name */
+				if ((di % SZDIRE) == 0) di += 2;
+				if (ff_wtoupper(ld_word(fs->dirbuf + di)) != ff_wtoupper(fs->lfnbuf[ni])) break;
+			}
+			if (nc == 0 && !fs->lfnbuf[ni]) break;	/* Name matched? */
+		}
+		return res;
+	}
+#endif
+	/* At the FAT12/16/32 */
+#if _USE_LFN != 0
+	ord = sum = 0xFF; dp->blk_ofs = 0xFFFFFFFF;	/* Reset LFN sequence */
+#endif
+	do {
+		res = move_window(fs, dp->sect);
+		if (res != FR_OK) break;
+		c = dp->dir[DIR_Name];
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */
+#if _USE_LFN != 0	/* LFN configuration */
+		dp->obj.attr = a = dp->dir[DIR_Attr] & AM_MASK;
+		if (c == DDEM || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */
+			ord = 0xFF; dp->blk_ofs = 0xFFFFFFFF;	/* Reset LFN sequence */
+		} else {
+			if (a == AM_LFN) {			/* An LFN entry is found */
+				if (!(dp->fn[NSFLAG] & NS_NOLFN)) {
+					if (c & LLEF) {		/* Is it start of LFN sequence? */
+						sum = dp->dir[LDIR_Chksum];
+						c &= ~LLEF; ord = c;	/* LFN start order */
+						dp->blk_ofs = dp->dptr;	/* Start offset of LFN */
+					}
+					/* Check validity of the LFN entry and compare it with given name */
+					ord = (c == ord && sum == dp->dir[LDIR_Chksum] && cmp_lfn(fs->lfnbuf, dp->dir)) ? ord - 1 : 0xFF;
+				}
+			} else {					/* An SFN entry is found */
+				if (!ord && sum == sum_sfn(dp->dir)) break;	/* LFN matched? */
+				if (!(dp->fn[NSFLAG] & NS_LOSS) && !mem_cmp(dp->dir, dp->fn, 11)) break;	/* SFN matched? */
+				ord = 0xFF; dp->blk_ofs = 0xFFFFFFFF;	/* Reset LFN sequence */
+			}
+		}
+#else		/* Non LFN configuration */
+		dp->obj.attr = dp->dir[DIR_Attr] & AM_MASK;
+		if (!(dp->dir[DIR_Attr] & AM_VOL) && !mem_cmp(dp->dir, dp->fn, 11)) break;	/* Is it a valid entry? */
+#endif
+		res = dir_next(dp, 0);	/* Next entry */
+	} while (res == FR_OK);
+
+	return res;
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Register an object to the directory                                   */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_register (	/* FR_OK:succeeded, FR_DENIED:no free entry or too many SFN collision, FR_DISK_ERR:disk error */
+	DIR* dp				/* Target directory with object name to be created */
+)
+{
+	FRESULT res;
+	FATFS *fs = dp->obj.fs;
+#if _USE_LFN != 0	/* LFN configuration */
+	UINT n, nlen, nent;
+	BYTE sn[12], sum;
+
+
+	if (dp->fn[NSFLAG] & (NS_DOT | NS_NONAME)) return FR_INVALID_NAME;	/* Check name validity */
+	for (nlen = 0; fs->lfnbuf[nlen]; nlen++) ;	/* Get lfn length */
+
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+		DIR dj;
+
+		nent = (nlen + 14) / 15 + 2;	/* Number of entries to allocate (85+C0+C1s) */
+		res = dir_alloc(dp, nent);		/* Allocate entries */
+		if (res != FR_OK) return res;
+		dp->blk_ofs = dp->dptr - SZDIRE * (nent - 1);			/* Set block position */
+
+		if (dp->obj.sclust != 0 && (dp->obj.stat & 4)) {	/* Has the sub-directory been stretched? */
+			dp->obj.stat &= 3;
+			dp->obj.objsize += (DWORD)fs->csize * SS(fs);	/* Increase object size by cluster size */
+			res = fill_fat_chain(&dp->obj);	/* Complement FAT chain if needed */
+			if (res != FR_OK) return res;
+			res = load_obj_dir(&dj, &dp->obj);
+			if (res != FR_OK) return res;	/* Load the object status */
+			st_qword(fs->dirbuf + XDIR_FileSize, dp->obj.objsize);		/* Update the allocation status */
+			st_qword(fs->dirbuf + XDIR_ValidFileSize, dp->obj.objsize);
+			fs->dirbuf[XDIR_GenFlags] = dp->obj.stat | 1;
+			res = store_xdir(&dj);			/* Store the object status */
+			if (res != FR_OK) return res;
+		}
+
+		create_xdir(fs->dirbuf, fs->lfnbuf);	/* Create on-memory directory block to be written later */
+		return FR_OK;
+	}
+#endif
+	/* At the FAT12/16/32 */
+	mem_cpy(sn, dp->fn, 12);
+	if (sn[NSFLAG] & NS_LOSS) {			/* When LFN is out of 8.3 format, generate a numbered name */
+		dp->fn[NSFLAG] = NS_NOLFN;		/* Find only SFN */
+		for (n = 1; n < 100; n++) {
+			gen_numname(dp->fn, sn, fs->lfnbuf, n);	/* Generate a numbered name */
+			res = dir_find(dp);				/* Check if the name collides with existing SFN */
+			if (res != FR_OK) break;
+		}
+		if (n == 100) return FR_DENIED;		/* Abort if too many collisions */
+		if (res != FR_NO_FILE) return res;	/* Abort if the result is other than 'not collided' */
+		dp->fn[NSFLAG] = sn[NSFLAG];
+	}
+
+	/* Create an SFN with/without LFNs. */
+	nent = (sn[NSFLAG] & NS_LFN) ? (nlen + 12) / 13 + 1 : 1;	/* Number of entries to allocate */
+	res = dir_alloc(dp, nent);		/* Allocate entries */
+	if (res == FR_OK && --nent) {	/* Set LFN entry if needed */
+		res = dir_sdi(dp, dp->dptr - nent * SZDIRE);
+		if (res == FR_OK) {
+			sum = sum_sfn(dp->fn);	/* Checksum value of the SFN tied to the LFN */
+			do {					/* Store LFN entries in bottom first */
+				res = move_window(fs, dp->sect);
+				if (res != FR_OK) break;
+				put_lfn(fs->lfnbuf, dp->dir, (BYTE)nent, sum);
+				fs->wflag = 1;
+				res = dir_next(dp, 0);	/* Next entry */
+			} while (res == FR_OK && --nent);
+		}
+	}
+
+#else	/* Non LFN configuration */
+	res = dir_alloc(dp, 1);		/* Allocate an entry for SFN */
+
+#endif
+
+	/* Set SFN entry */
+	if (res == FR_OK) {
+		res = move_window(fs, dp->sect);
+		if (res == FR_OK) {
+			mem_set(dp->dir, 0, SZDIRE);	/* Clean the entry */
+			mem_cpy(dp->dir + DIR_Name, dp->fn, 11);	/* Put SFN */
+#if _USE_LFN != 0
+			dp->dir[DIR_NTres] = dp->fn[NSFLAG] & (NS_BODY | NS_EXT);	/* Put NT flag */
+#endif
+			fs->wflag = 1;
+		}
+	}
+
+	return res;
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+#if !_FS_READONLY && _FS_MINIMIZE == 0
+/*-----------------------------------------------------------------------*/
+/* Remove an object from the directory                                   */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_remove (	/* FR_OK:Succeeded, FR_DISK_ERR:A disk error */
+	DIR* dp				/* Directory object pointing the entry to be removed */
+)
+{
+	FRESULT res;
+	FATFS *fs = dp->obj.fs;
+#if _USE_LFN != 0	/* LFN configuration */
+	DWORD last = dp->dptr;
+
+	res = (dp->blk_ofs == 0xFFFFFFFF) ? FR_OK : dir_sdi(dp, dp->blk_ofs);	/* Goto top of the entry block if LFN is exist */
+	if (res == FR_OK) {
+		do {
+			res = move_window(fs, dp->sect);
+			if (res != FR_OK) break;
+			/* Mark an entry 'deleted' */
+			if (_FS_EXFAT && fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+				dp->dir[XDIR_Type] &= 0x7F;
+			} else {									/* At the FAT12/16/32 */
+				dp->dir[DIR_Name] = DDEM;
+			}
+			fs->wflag = 1;
+			if (dp->dptr >= last) break;	/* If reached last entry then all entries of the object has been deleted. */
+			res = dir_next(dp, 0);	/* Next entry */
+		} while (res == FR_OK);
+		if (res == FR_NO_FILE) res = FR_INT_ERR;
+	}
+#else			/* Non LFN configuration */
+
+	res = move_window(fs, dp->sect);
+	if (res == FR_OK) {
+		dp->dir[DIR_Name] = DDEM;
+		fs->wflag = 1;
+	}
+#endif
+
+	return res;
+}
+
+#endif /* !_FS_READONLY && _FS_MINIMIZE == 0 */
+
+
+
+#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2
+/*-----------------------------------------------------------------------*/
+/* Get file information from directory entry                             */
+/*-----------------------------------------------------------------------*/
+
+static
+void get_fileinfo (		/* No return code */
+	DIR* dp,			/* Pointer to the directory object */
+	FILINFO* fno	 	/* Pointer to the file information to be filled */
+)
+{
+	UINT i, j;
+	TCHAR c;
+	DWORD tm;
+#if _USE_LFN != 0
+	WCHAR w, lfv;
+	FATFS *fs = dp->obj.fs;
+#endif
+
+
+	fno->fname[0] = 0;		/* Invaidate file info */
+	if (!dp->sect) return;	/* Exit if read pointer has reached end of directory */
+
+#if _USE_LFN != 0	/* LFN configuration */
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+		get_xdir_info(fs->dirbuf, fno);
+		return;
+	} else
+#endif
+	{	/* At the FAT12/16/32 */
+		if (dp->blk_ofs != 0xFFFFFFFF) {	/* Get LFN if available */
+			i = j = 0;
+			while ((w = fs->lfnbuf[j++]) != 0) {	/* Get an LFN character */
+#if !_LFN_UNICODE
+				w = ff_convert(w, 0);		/* Unicode -> OEM */
+				if (w == 0) { i = 0; break; }	/* No LFN if it could not be converted */
+				if (_DF1S && w >= 0x100) {	/* Put 1st byte if it is a DBC (always false at SBCS cfg) */
+					fno->fname[i++] = (char)(w >> 8);
+				}
+#endif
+				if (i >= _MAX_LFN) { i = 0; break; }	/* No LFN if buffer overflow */
+				fno->fname[i++] = (TCHAR)w;
+			}
+			fno->fname[i] = 0;	/* Terminate the LFN */
+		}
+	}
+
+	i = j = 0;
+	lfv = fno->fname[i];	/* LFN is exist if non-zero */
+	while (i < 11) {		/* Copy name body and extension */
+		c = (TCHAR)dp->dir[i++];
+		if (c == ' ') continue;				/* Skip padding spaces */
+		if (c == RDDEM) c = (TCHAR)DDEM;	/* Restore replaced DDEM character */
+		if (i == 9) {						/* Insert a . if extension is exist */
+			if (!lfv) fno->fname[j] = '.';
+			fno->altname[j++] = '.';
+		}
+#if _LFN_UNICODE
+		if (IsDBCS1(c) && i != 8 && i != 11 && IsDBCS2(dp->dir[i])) {
+			c = c << 8 | dp->dir[i++];
+		}
+		c = ff_convert(c, 1);	/* OEM -> Unicode */
+		if (!c) c = '?';
+#endif
+		fno->altname[j] = c;
+		if (!lfv) {
+			if (IsUpper(c) && (dp->dir[DIR_NTres] & (i >= 9 ? NS_EXT : NS_BODY))) {
+				c += 0x20;			/* To lower */
+			}
+			fno->fname[j] = c;
+		}
+		j++;
+	}
+	if (!lfv) {
+		fno->fname[j] = 0;
+		if (!dp->dir[DIR_NTres]) j = 0;	/* Altname is no longer needed if neither LFN nor case info is exist. */
+	}
+	fno->altname[j] = 0;	/* Terminate the SFN */
+
+#else	/* Non-LFN configuration */
+	i = j = 0;
+	while (i < 11) {		/* Copy name body and extension */
+		c = (TCHAR)dp->dir[i++];
+		if (c == ' ') continue;				/* Skip padding spaces */
+		if (c == RDDEM) c = (TCHAR)DDEM;	/* Restore replaced DDEM character */
+		if (i == 9) fno->fname[j++] = '.';	/* Insert a . if extension is exist */
+		fno->fname[j++] = c;
+	}
+	fno->fname[j] = 0;
+#endif
+
+	fno->fattrib = dp->dir[DIR_Attr];				/* Attribute */
+	fno->fsize = ld_dword(dp->dir + DIR_FileSize);	/* Size */
+	tm = ld_dword(dp->dir + DIR_ModTime);			/* Timestamp */
+	fno->ftime = (WORD)tm; fno->fdate = (WORD)(tm >> 16);
+}
+
+#endif /* _FS_MINIMIZE <= 1 || _FS_RPATH >= 2 */
+
+
+
+#if _USE_FIND && _FS_MINIMIZE <= 1
+/*-----------------------------------------------------------------------*/
+/* Pattern matching                                                      */
+/*-----------------------------------------------------------------------*/
+
+static
+WCHAR get_achar (		/* Get a character and advances ptr 1 or 2 */
+	const TCHAR** ptr	/* Pointer to pointer to the SBCS/DBCS/Unicode string */
+)
+{
+#if !_LFN_UNICODE
+	WCHAR chr;
+
+	chr = (BYTE)*(*ptr)++;					/* Get a byte */
+	if (IsLower(chr)) chr -= 0x20;			/* To upper ASCII char */
+#ifdef _EXCVT
+	if (chr >= 0x80) chr = ExCvt[chr - 0x80];	/* To upper SBCS extended char */
+#else
+	if (IsDBCS1(chr) && IsDBCS2(**ptr)) {		/* Get DBC 2nd byte if needed */
+		chr = chr << 8 | (BYTE)*(*ptr)++;
+	}
+#endif
+	return chr;
+#else
+	return ff_wtoupper(*(*ptr)++);			/* Get a word and to upper */
+#endif
+}
+
+
+static
+int pattern_matching (	/* 0:not matched, 1:matched */
+	const TCHAR* pat,	/* Matching pattern */
+	const TCHAR* nam,	/* String to be tested */
+	int skip,			/* Number of pre-skip chars (number of ?s) */
+	int inf				/* Infinite search (* specified) */
+)
+{
+	const TCHAR *pp, *np;
+	WCHAR pc, nc;
+	int nm, nx;
+
+
+	while (skip--) {				/* Pre-skip name chars */
+		if (!get_achar(&nam)) return 0;	/* Branch mismatched if less name chars */
+	}
+	if (!*pat && inf) return 1;		/* (short circuit) */
+
+	do {
+		pp = pat; np = nam;			/* Top of pattern and name to match */
+		for (;;) {
+			if (*pp == '?' || *pp == '*') {	/* Wildcard? */
+				nm = nx = 0;
+				do {				/* Analyze the wildcard chars */
+					if (*pp++ == '?') nm++; else nx = 1;
+				} while (*pp == '?' || *pp == '*');
+				if (pattern_matching(pp, np, nm, nx)) return 1;	/* Test new branch (recurs upto number of wildcard blocks in the pattern) */
+				nc = *np; break;	/* Branch mismatched */
+			}
+			pc = get_achar(&pp);	/* Get a pattern char */
+			nc = get_achar(&np);	/* Get a name char */
+			if (pc != nc) break;	/* Branch mismatched? */
+			if (pc == 0) return 1;	/* Branch matched? (matched at end of both strings) */
+		}
+		get_achar(&nam);			/* nam++ */
+	} while (inf && nc);			/* Retry until end of name if infinite search is specified */
+
+	return 0;
+}
+
+#endif /* _USE_FIND && _FS_MINIMIZE <= 1 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Pick a top segment and create the object name in directory form       */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT create_name (	/* FR_OK: successful, FR_INVALID_NAME: could not create */
+	DIR* dp,			/* Pointer to the directory object */
+	const TCHAR** path	/* Pointer to pointer to the segment in the path string */
+)
+{
+#if _USE_LFN != 0	/* LFN configuration */
+	BYTE b, cf;
+	WCHAR w, *lfn;
+	UINT i, ni, si, di;
+	const TCHAR *p;
+
+	/* Create LFN in Unicode */
+	p = *path; lfn = dp->obj.fs->lfnbuf; si = di = 0;
+	for (;;) {
+		w = p[si++];					/* Get a character */
+		if (w < ' ') break;				/* Break if end of the path name */
+		if (w == '/' || w == '\\') {	/* Break if a separator is found */
+			while (p[si] == '/' || p[si] == '\\') si++;	/* Skip duplicated separator if exist */
+			break;
+		}
+		if (di >= _MAX_LFN) return FR_INVALID_NAME;	/* Reject too long name */
+#if !_LFN_UNICODE
+		w &= 0xFF;
+		if (IsDBCS1(w)) {				/* Check if it is a DBC 1st byte (always false on SBCS cfg) */
+			b = (BYTE)p[si++];			/* Get 2nd byte */
+			w = (w << 8) + b;			/* Create a DBC */
+			if (!IsDBCS2(b)) return FR_INVALID_NAME;	/* Reject invalid sequence */
+		}
+		w = ff_convert(w, 1);			/* Convert ANSI/OEM to Unicode */
+		if (!w) return FR_INVALID_NAME;	/* Reject invalid code */
+#endif
+		if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) return FR_INVALID_NAME;	/* Reject illegal characters for LFN */
+		lfn[di++] = w;					/* Store the Unicode character */
+	}
+	*path = &p[si];						/* Return pointer to the next segment */
+	cf = (w < ' ') ? NS_LAST : 0;		/* Set last segment flag if end of the path */
+#if _FS_RPATH != 0
+	if ((di == 1 && lfn[di - 1] == '.') ||
+		(di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {	/* Is this segment a dot name? */
+		lfn[di] = 0;
+		for (i = 0; i < 11; i++)		/* Create dot name for SFN entry */
+			dp->fn[i] = (i < di) ? '.' : ' ';
+		dp->fn[i] = cf | NS_DOT;		/* This is a dot entry */
+		return FR_OK;
+	}
+#endif
+	while (di) {						/* Snip off trailing spaces and dots if exist */
+		w = lfn[di - 1];
+		if (w != ' ' && w != '.') break;
+		di--;
+	}
+	lfn[di] = 0;						/* LFN is created */
+	if (di == 0) return FR_INVALID_NAME;	/* Reject nul name */
+
+	/* Create SFN in directory form */
+	mem_set(dp->fn, ' ', 11);
+	for (si = 0; lfn[si] == ' ' || lfn[si] == '.'; si++) ;	/* Strip leading spaces and dots */
+	if (si) cf |= NS_LOSS | NS_LFN;
+	while (di && lfn[di - 1] != '.') di--;	/* Find extension (di<=si: no extension) */
+
+	b = i = 0; ni = 8;
+	for (;;) {
+		w = lfn[si++];					/* Get an LFN character */
+		if (!w) break;					/* Break on end of the LFN */
+		if (w == ' ' || (w == '.' && si != di)) {	/* Remove spaces and dots */
+			cf |= NS_LOSS | NS_LFN; continue;
+		}
+
+		if (i >= ni || si == di) {		/* Extension or end of SFN */
+			if (ni == 11) {				/* Long extension */
+				cf |= NS_LOSS | NS_LFN; break;
+			}
+			if (si != di) cf |= NS_LOSS | NS_LFN;	/* Out of 8.3 format */
+			if (si > di) break;			/* No extension */
+			si = di; i = 8; ni = 11;	/* Enter extension section */
+			b <<= 2; continue;
+		}
+
+		if (w >= 0x80) {				/* Non ASCII character */
+#ifdef _EXCVT
+			w = ff_convert(w, 0);		/* Unicode -> OEM code */
+			if (w) w = ExCvt[w - 0x80];	/* Convert extended character to upper (SBCS) */
+#else
+			w = ff_convert(ff_wtoupper(w), 0);	/* Upper converted Unicode -> OEM code */
+#endif
+			cf |= NS_LFN;				/* Force create LFN entry */
+		}
+
+		if (_DF1S && w >= 0x100) {		/* Is this DBC? (always false at SBCS cfg) */
+			if (i >= ni - 1) {
+				cf |= NS_LOSS | NS_LFN; i = ni; continue;
+			}
+			dp->fn[i++] = (BYTE)(w >> 8);
+		} else {						/* SBC */
+			if (!w || chk_chr("+,;=[]", w)) {	/* Replace illegal characters for SFN */
+				w = '_'; cf |= NS_LOSS | NS_LFN;/* Lossy conversion */
+			} else {
+				if (IsUpper(w)) {		/* ASCII large capital */
+					b |= 2;
+				} else {
+					if (IsLower(w)) {	/* ASCII small capital */
+						b |= 1; w -= 0x20;
+					}
+				}
+			}
+		}
+		dp->fn[i++] = (BYTE)w;
+	}
+
+	if (dp->fn[0] == DDEM) dp->fn[0] = RDDEM;	/* If the first character collides with DDEM, replace it with RDDEM */
+
+	if (ni == 8) b <<= 2;
+	if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03) cf |= NS_LFN;	/* Create LFN entry when there are composite capitals */
+	if (!(cf & NS_LFN)) {						/* When LFN is in 8.3 format without extended character, NT flags are created */
+		if ((b & 0x03) == 0x01) cf |= NS_EXT;	/* NT flag (Extension has only small capital) */
+		if ((b & 0x0C) == 0x04) cf |= NS_BODY;	/* NT flag (Filename has only small capital) */
+	}
+
+	dp->fn[NSFLAG] = cf;	/* SFN is created */
+
+	return FR_OK;
+
+
+#else	/* _USE_LFN != 0 : Non-LFN configuration */
+	BYTE c, d, *sfn;
+	UINT ni, si, i;
+	const char *p;
+
+	/* Create file name in directory form */
+	p = *path; sfn = dp->fn;
+	mem_set(sfn, ' ', 11);
+	si = i = 0; ni = 8;
+#if _FS_RPATH != 0
+	if (p[si] == '.') { /* Is this a dot entry? */
+		for (;;) {
+			c = (BYTE)p[si++];
+			if (c != '.' || si >= 3) break;
+			sfn[i++] = c;
+		}
+		if (c != '/' && c != '\\' && c > ' ') return FR_INVALID_NAME;
+		*path = p + si;								/* Return pointer to the next segment */
+		sfn[NSFLAG] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT;	/* Set last segment flag if end of the path */
+		return FR_OK;
+	}
+#endif
+	for (;;) {
+		c = (BYTE)p[si++];
+		if (c <= ' ') break; 			/* Break if end of the path name */
+		if (c == '/' || c == '\\') {	/* Break if a separator is found */
+			while (p[si] == '/' || p[si] == '\\') si++;	/* Skip duplicated separator if exist */
+			break;
+		}
+		if (c == '.' || i >= ni) {		/* End of body or over size? */
+			if (ni == 11 || c != '.') return FR_INVALID_NAME;	/* Over size or invalid dot */
+			i = 8; ni = 11;				/* Goto extension */
+			continue;
+		}
+		if (c >= 0x80) {				/* Extended character? */
+#ifdef _EXCVT
+			c = ExCvt[c - 0x80];		/* To upper extended characters (SBCS cfg) */
+#else
+#if !_DF1S
+			return FR_INVALID_NAME;		/* Reject extended characters (ASCII only cfg) */
+#endif
+#endif
+		}
+		if (IsDBCS1(c)) {				/* Check if it is a DBC 1st byte (always false at SBCS cfg.) */
+			d = (BYTE)p[si++];			/* Get 2nd byte */
+			if (!IsDBCS2(d) || i >= ni - 1) return FR_INVALID_NAME;	/* Reject invalid DBC */
+			sfn[i++] = c;
+			sfn[i++] = d;
+		} else {						/* SBC */
+			if (chk_chr("\"*+,:;<=>\?[]|\x7F", c)) return FR_INVALID_NAME;	/* Reject illegal chrs for SFN */
+			if (IsLower(c)) c -= 0x20;	/* To upper */
+			sfn[i++] = c;
+		}
+	}
+	*path = p + si;						/* Return pointer to the next segment */
+	if (i == 0) return FR_INVALID_NAME;	/* Reject nul string */
+
+	if (sfn[0] == DDEM) sfn[0] = RDDEM;	/* If the first character collides with DDEM, replace it with RDDEM */
+	sfn[NSFLAG] = (c <= ' ') ? NS_LAST : 0;		/* Set last segment flag if end of the path */
+
+	return FR_OK;
+#endif /* _USE_LFN != 0 */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Follow a file path                                                    */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */
+	DIR* dp,			/* Directory object to return last directory and found object */
+	const TCHAR* path	/* Full-path string to find a file or directory */
+)
+{
+	FRESULT res;
+	BYTE ns;
+	_FDID *obj = &dp->obj;
+	FATFS *fs = obj->fs;
+
+
+#if _FS_RPATH != 0
+	if (*path != '/' && *path != '\\') {	/* Without heading separator */
+		obj->sclust = fs->cdir;				/* Start from the current directory */
+	} else
+#endif
+	{										/* With heading separator */
+		while (*path == '/' || *path == '\\') path++;	/* Strip heading separator */
+		obj->sclust = 0;					/* Start from the root directory */
+	}
+#if _FS_EXFAT && _FS_RPATH != 0
+	if (fs->fs_type == FS_EXFAT && obj->sclust) {	/* Retrieve the sub-directory status if needed */
+		DIR dj;
+
+		obj->c_scl = fs->cdc_scl;
+		obj->c_size = fs->cdc_size;
+		obj->c_ofs = fs->cdc_ofs;
+		res = load_obj_dir(&dj, obj);
+		if (res != FR_OK) return res;
+		obj->objsize = ld_dword(fs->dirbuf + XDIR_FileSize);
+		obj->stat = fs->dirbuf[XDIR_GenFlags] & 2;
+	}
+#endif
+
+	if ((UINT)*path < ' ') {				/* Null path name is the origin directory itself */
+		dp->fn[NSFLAG] = NS_NONAME;
+		res = dir_sdi(dp, 0);
+
+	} else {								/* Follow path */
+		for (;;) {
+			res = create_name(dp, &path);	/* Get a segment name of the path */
+			if (res != FR_OK) break;
+			res = dir_find(dp);				/* Find an object with the segment name */
+			ns = dp->fn[NSFLAG];
+			if (res != FR_OK) {				/* Failed to find the object */
+				if (res == FR_NO_FILE) {	/* Object is not found */
+					if (_FS_RPATH && (ns & NS_DOT)) {	/* If dot entry is not exist, stay there */
+						if (!(ns & NS_LAST)) continue;	/* Continue to follow if not last segment */
+						dp->fn[NSFLAG] = NS_NONAME;
+						res = FR_OK;
+					} else {							/* Could not find the object */
+						if (!(ns & NS_LAST)) res = FR_NO_PATH;	/* Adjust error code if not last segment */
+					}
+				}
+				break;
+			}
+			if (ns & NS_LAST) break;			/* Last segment matched. Function completed. */
+			/* Get into the sub-directory */
+			if (!(obj->attr & AM_DIR)) {		/* It is not a sub-directory and cannot follow */
+				res = FR_NO_PATH; break;
+			}
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				obj->c_scl = obj->sclust;		/* Save containing directory information for next dir */
+				obj->c_size = ((DWORD)obj->objsize & 0xFFFFFF00) | obj->stat;
+				obj->c_ofs = dp->blk_ofs;
+				obj->sclust = ld_dword(fs->dirbuf + XDIR_FstClus);	/* Open next directory */
+				obj->stat = fs->dirbuf[XDIR_GenFlags] & 2;
+				obj->objsize = ld_qword(fs->dirbuf + XDIR_FileSize);
+			} else
+#endif
+			{
+				obj->sclust = ld_clust(fs, fs->win + dp->dptr % SS(fs));	/* Open next directory */
+			}
+		}
+	}
+
+	return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get logical drive number from path name                               */
+/*-----------------------------------------------------------------------*/
+
+static
+int get_ldnumber (		/* Returns logical drive number (-1:invalid drive) */
+	const TCHAR** path	/* Pointer to pointer to the path name */
+)
+{
+	const TCHAR *tp, *tt;
+	UINT i;
+	int vol = -1;
+#if _STR_VOLUME_ID		/* Find string drive id */
+	static const char* const str[] = {_VOLUME_STRS};
+	const char *sp;
+	char c;
+	TCHAR tc;
+#endif
+
+
+	if (*path) {	/* If the pointer is not a null */
+		for (tt = *path; (UINT)*tt >= (_USE_LFN ? ' ' : '!') && *tt != ':'; tt++) ;	/* Find ':' in the path */
+		if (*tt == ':') {	/* If a ':' is exist in the path name */
+			tp = *path;
+			i = *tp++ - '0'; 
+			if (i < 10 && tp == tt) {	/* Is there a numeric drive id? */
+				if (i < _VOLUMES) {	/* If a drive id is found, get the value and strip it */
+					vol = (int)i;
+					*path = ++tt;
+				}
+			}
+#if _STR_VOLUME_ID
+			 else {	/* No numeric drive number, find string drive id */
+				i = 0; tt++;
+				do {
+					sp = str[i]; tp = *path;
+					do {	/* Compare a string drive id with path name */
+						c = *sp++; tc = *tp++;
+						if (IsLower(tc)) tc -= 0x20;
+					} while (c && (TCHAR)c == tc);
+				} while ((c || tp != tt) && ++i < _VOLUMES);	/* Repeat for each id until pattern match */
+				if (i < _VOLUMES) {	/* If a drive id is found, get the value and strip it */
+					vol = (int)i;
+					*path = tt;
+				}
+			}
+#endif
+			return vol;
+		}
+#if _FS_RPATH != 0 && _VOLUMES >= 2
+		vol = CurrVol;	/* Current drive */
+#else
+		vol = 0;		/* Drive 0 */
+#endif
+	}
+	return vol;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Load a sector and check if it is an FAT boot sector                   */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE check_fs (	/* 0:FAT, 1:exFAT, 2:Valid BS but not FAT, 3:Not a BS, 4:Disk error */
+	FATFS* fs,	/* File system object */
+	DWORD sect	/* Sector# (lba) to check if it is an FAT-VBR or not */
+)
+{
+	fs->wflag = 0; fs->winsect = 0xFFFFFFFF;		/* Invaidate window */
+	if (move_window(fs, sect) != FR_OK) return 4;	/* Load boot record */
+
+	if (ld_word(fs->win + BS_55AA) != 0xAA55) return 3;	/* Check boot record signature (always placed at offset 510 even if the sector size is >512) */
+
+	if (fs->win[BS_JmpBoot] == 0xE9 || (fs->win[BS_JmpBoot] == 0xEB && fs->win[BS_JmpBoot + 2] == 0x90)) {
+		if ((ld_dword(fs->win + BS_FilSysType) & 0xFFFFFF) == 0x544146) return 0;	/* Check "FAT" string */
+		if (ld_dword(fs->win + BS_FilSysType32) == 0x33544146) return 0;			/* Check "FAT3" string */
+	}
+#if _FS_EXFAT
+	if (!mem_cmp(fs->win + BS_JmpBoot, "\xEB\x76\x90" "EXFAT   ", 11)) return 1;
+#endif
+	return 2;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Find logical drive and check if the volume is mounted                 */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
+	const TCHAR** path,	/* Pointer to pointer to the path name (drive number) */
+	FATFS** rfs,		/* Pointer to pointer to the found file system object */
+	BYTE mode			/* !=0: Check write protection for write access */
+)
+{
+	BYTE fmt, *pt;
+	int vol;
+	DSTATUS stat;
+	DWORD bsect, fasize, tsect, sysect, nclst, szbfat, br[4];
+	WORD nrsv;
+	FATFS *fs;
+	UINT i;
+
+
+	/* Get logical drive number from the path name */
+	*rfs = 0;
+	vol = get_ldnumber(path);
+	if (vol < 0) return FR_INVALID_DRIVE;
+
+	/* Check if the file system object is valid or not */
+	fs = FatFs[vol];					/* Get pointer to the file system object */
+	if (!fs) return FR_NOT_ENABLED;		/* Is the file system object available? */
+
+	ENTER_FF(fs);						/* Lock the volume */
+	*rfs = fs;							/* Return pointer to the file system object */
+
+	mode &= ~FA_READ;					/* Desired access mode, write access or not */
+	if (fs->fs_type) {					/* If the volume has been mounted */
+		stat = disk_status(fs->drv);
+		if (!(stat & STA_NOINIT)) {		/* and the physical drive is kept initialized */
+			if (!_FS_READONLY && mode && (stat & STA_PROTECT)) {	/* Check write protection if needed */
+				return FR_WRITE_PROTECTED;
+			}
+			return FR_OK;				/* The file system object is valid */
+		}
+	}
+
+	/* The file system object is not valid. */
+	/* Following code attempts to mount the volume. (analyze BPB and initialize the fs object) */
+
+	fs->fs_type = 0;					/* Clear the file system object */
+	fs->drv = LD2PD(vol);				/* Bind the logical drive and a physical drive */
+	stat = disk_initialize(fs->drv);	/* Initialize the physical drive */
+	if (stat & STA_NOINIT) { 			/* Check if the initialization succeeded */
+		return FR_NOT_READY;			/* Failed to initialize due to no medium or hard error */
+	}
+	if (!_FS_READONLY && mode && (stat & STA_PROTECT)) { /* Check disk write protection if needed */
+		return FR_WRITE_PROTECTED;
+	}
+#if _MAX_SS != _MIN_SS						/* Get sector size (multiple sector size cfg only) */
+	if (disk_ioctl(fs->drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK) return FR_DISK_ERR;
+	if (SS(fs) > _MAX_SS || SS(fs) < _MIN_SS || (SS(fs) & (SS(fs) - 1))) return FR_DISK_ERR;
+#endif
+	/* Find an FAT partition on the drive. Supports only generic partitioning, FDISK and SFD. */
+	bsect = 0;
+	fmt = check_fs(fs, bsect);			/* Load sector 0 and check if it is an FAT-VBR as SFD */
+	if (fmt == 2 || (fmt < 2 && LD2PT(vol) != 0)) {	/* Not an FAT-VBR or forced partition number */
+		for (i = 0; i < 4; i++) {			/* Get partition offset */
+			pt = fs->win + (MBR_Table + i * SZ_PTE);
+			br[i] = pt[PTE_System] ? ld_dword(pt + PTE_StLba) : 0;
+		}
+		i = LD2PT(vol);						/* Partition number: 0:auto, 1-4:forced */
+		if (i) i--;
+		do {								/* Find an FAT volume */
+			bsect = br[i];
+			fmt = bsect ? check_fs(fs, bsect) : 3;	/* Check the partition */
+		} while (!LD2PT(vol) && fmt >= 2 && ++i < 4);
+	}
+	if (fmt == 4) return FR_DISK_ERR;		/* An error occured in the disk I/O layer */
+	if (fmt >= 2) return FR_NO_FILESYSTEM;	/* No FAT volume is found */
+
+	/* An FAT volume is found. Following code initializes the file system object */
+
+#if _FS_EXFAT
+	if (fmt == 1) {
+		QWORD maxlba;
+
+		for (i = BPB_ZeroedEx; i < BPB_ZeroedEx + 53 && fs->win[i] == 0; i++) ;	/* Check zero filler */
+		if (i < BPB_ZeroedEx + 53) return FR_NO_FILESYSTEM;
+
+		if (ld_word(fs->win + BPB_FSVerEx) != 0x100) return FR_NO_FILESYSTEM;	/* Check exFAT revision (Must be 1.0) */
+
+		if (1 << fs->win[BPB_BytsPerSecEx] != SS(fs))	/* (BPB_BytsPerSecEx must be equal to the physical sector size) */
+			return FR_NO_FILESYSTEM;
+
+		maxlba = ld_qword(fs->win + BPB_TotSecEx) + bsect;	/* Last LBA + 1 of the volume */
+		if (maxlba >= 0x100000000) return FR_NO_FILESYSTEM;	/* (It cannot be handled in 32-bit LBA) */
+
+		fs->fsize = ld_dword(fs->win + BPB_FatSzEx);	/* Number of sectors per FAT */
+
+		fs->n_fats = fs->win[BPB_NumFATsEx];			/* Number of FATs */
+		if (fs->n_fats != 1) return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */
+
+		fs->csize = 1 << fs->win[BPB_SecPerClusEx];		/* Cluster size */
+		if (fs->csize == 0)	return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */
+
+		nclst = ld_dword(fs->win + BPB_NumClusEx);		/* Number of clusters */
+		if (nclst > MAX_EXFAT) return FR_NO_FILESYSTEM;	/* (Too many clusters) */
+		fs->n_fatent = nclst + 2;
+
+		/* Boundaries and Limits */
+		fs->volbase = bsect;
+		fs->database = bsect + ld_dword(fs->win + BPB_DataOfsEx);
+		fs->fatbase = bsect + ld_dword(fs->win + BPB_FatOfsEx);
+		if (maxlba < fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size requiered) */
+		fs->dirbase = ld_dword(fs->win + BPB_RootClusEx);
+
+		/* Check if bitmap location is in assumption (at the first cluster) */
+		if (move_window(fs, clust2sect(fs, fs->dirbase)) != FR_OK) return FR_DISK_ERR;
+		for (i = 0; i < SS(fs); i += SZDIRE) {
+			if (fs->win[i] == 0x81 && ld_dword(fs->win + i + 20) == 2) break;	/* 81 entry with cluster #2? */
+		}
+		if (i == SS(fs)) return FR_NO_FILESYSTEM;
+#if !_FS_READONLY
+		fs->last_clst = fs->free_clst = 0xFFFFFFFF;		/* Initialize cluster allocation information */
+#endif
+		fmt = FS_EXFAT;			/* FAT sub-type */
+	} else
+#endif	/* _FS_EXFAT */
+	{
+		if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_BytsPerSec must be equal to the physical sector size) */
+
+		fasize = ld_word(fs->win + BPB_FATSz16);			/* Number of sectors per FAT */
+		if (fasize == 0) fasize = ld_dword(fs->win + BPB_FATSz32);
+		fs->fsize = fasize;
+
+		fs->n_fats = fs->win[BPB_NumFATs];					/* Number of FATs */
+		if (fs->n_fats != 1 && fs->n_fats != 2) return FR_NO_FILESYSTEM;	/* (Must be 1 or 2) */
+		fasize *= fs->n_fats;								/* Number of sectors for FAT area */
+
+		fs->csize = fs->win[BPB_SecPerClus];				/* Cluster size */
+		if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) return FR_NO_FILESYSTEM;	/* (Must be power of 2) */
+
+		fs->n_rootdir = ld_word(fs->win + BPB_RootEntCnt);	/* Number of root directory entries */
+		if (fs->n_rootdir % (SS(fs) / SZDIRE)) return FR_NO_FILESYSTEM;	/* (Must be sector aligned) */
+
+		tsect = ld_word(fs->win + BPB_TotSec16);			/* Number of sectors on the volume */
+		if (tsect == 0) tsect = ld_dword(fs->win + BPB_TotSec32);
+
+		nrsv = ld_word(fs->win + BPB_RsvdSecCnt);			/* Number of reserved sectors */
+		if (nrsv == 0) return FR_NO_FILESYSTEM;				/* (Must not be 0) */
+
+		/* Determine the FAT sub type */
+		sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZDIRE);	/* RSV + FAT + DIR */
+		if (tsect < sysect) return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
+		nclst = (tsect - sysect) / fs->csize;				/* Number of clusters */
+		if (nclst == 0) return FR_NO_FILESYSTEM;			/* (Invalid volume size) */
+		fmt = FS_FAT32;
+		if (nclst <= MAX_FAT16) fmt = FS_FAT16;
+		if (nclst <= MAX_FAT12) fmt = FS_FAT12;
+
+		/* Boundaries and Limits */
+		fs->n_fatent = nclst + 2;							/* Number of FAT entries */
+		fs->volbase = bsect;								/* Volume start sector */
+		fs->fatbase = bsect + nrsv; 						/* FAT start sector */
+		fs->database = bsect + sysect;						/* Data start sector */
+		if (fmt == FS_FAT32) {
+			if (ld_word(fs->win + BPB_FSVer32) != 0) return FR_NO_FILESYSTEM;	/* (Must be FAT32 revision 0.0) */
+			if (fs->n_rootdir) return FR_NO_FILESYSTEM;		/* (BPB_RootEntCnt must be 0) */
+			fs->dirbase = ld_dword(fs->win + BPB_RootClus32);	/* Root directory start cluster */
+			szbfat = fs->n_fatent * 4;						/* (Needed FAT size) */
+		} else {
+			if (fs->n_rootdir == 0)	return FR_NO_FILESYSTEM;/* (BPB_RootEntCnt must not be 0) */
+			fs->dirbase = fs->fatbase + fasize;				/* Root directory start sector */
+			szbfat = (fmt == FS_FAT16) ?					/* (Needed FAT size) */
+				fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
+		}
+		if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_FATSz must not be less than the size needed) */
+
+#if !_FS_READONLY
+		/* Get FSINFO if available */
+		fs->last_clst = fs->free_clst = 0xFFFFFFFF;		/* Initialize cluster allocation information */
+		fs->fsi_flag = 0x80;
+#if (_FS_NOFSINFO & 3) != 3
+		if (fmt == FS_FAT32				/* Enable FSINFO only if FAT32 and BPB_FSInfo32 == 1 */
+			&& ld_word(fs->win + BPB_FSInfo32) == 1
+			&& move_window(fs, bsect + 1) == FR_OK)
+		{
+			fs->fsi_flag = 0;
+			if (ld_word(fs->win + BS_55AA) == 0xAA55	/* Load FSINFO data if available */
+				&& ld_dword(fs->win + FSI_LeadSig) == 0x41615252
+				&& ld_dword(fs->win + FSI_StrucSig) == 0x61417272)
+			{
+#if (_FS_NOFSINFO & 1) == 0
+				fs->free_clst = ld_dword(fs->win + FSI_Free_Count);
+#endif
+#if (_FS_NOFSINFO & 2) == 0
+				fs->last_clst = ld_dword(fs->win + FSI_Nxt_Free);
+#endif
+			}
+		}
+#endif	/* (_FS_NOFSINFO & 3) != 3 */
+#endif	/* !_FS_READONLY */
+	}
+
+	fs->fs_type = fmt;	/* FAT sub-type */
+	fs->id = ++Fsid;	/* File system mount ID */
+#if _USE_LFN == 1
+	fs->lfnbuf = LfnBuf;	/* Static LFN working buffer */
+#if _FS_EXFAT
+	fs->dirbuf = DirBuf;	/* Static directory block working buuffer */
+#endif
+#endif
+#if _FS_RPATH != 0
+	fs->cdir = 0;		/* Initialize current directory */
+#endif
+#if _FS_LOCK != 0		/* Clear file lock semaphores */
+	clear_lock(fs);
+#endif
+	return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Check if the file/directory object is valid or not                    */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT validate (	/* Returns FR_OK or FR_INVALID_OBJECT */
+	void* dfp,		/* Pointer to the FIL/DIR object to check validity */
+	FATFS** fs		/* Pointer to pointer to the owner file system object to return */
+)
+{
+	_FDID *obj = (_FDID*)dfp;	/* Assuming .obj in the FIL/DIR is the first member */
+	FRESULT res;
+
+
+	if (!dfp || !obj->fs || !obj->fs->fs_type || obj->fs->id != obj->id || (disk_status(obj->fs->drv) & STA_NOINIT)) {
+		*fs = 0;				/* The object is invalid */
+		res = FR_INVALID_OBJECT;
+	} else {
+		*fs = obj->fs;			/* Owner file sytem object */
+		ENTER_FF(obj->fs);		/* Lock file system */
+		res = FR_OK;
+	}
+	return res;
+}
+
+
+
+
+/*---------------------------------------------------------------------------
+
+   Public Functions (FatFs API)
+
+----------------------------------------------------------------------------*/
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Mount/Unmount a Logical Drive                                         */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mount (
+	FATFS* fs,			/* Pointer to the file system object (NULL:unmount)*/
+	const TCHAR* path,	/* Logical drive number to be mounted/unmounted */
+	BYTE opt			/* Mode option 0:Do not mount (delayed mount), 1:Mount immediately */
+)
+{
+	FATFS *cfs;
+	int vol;
+	FRESULT res;
+	const TCHAR *rp = path;
+
+
+	vol = get_ldnumber(&rp);
+	if (vol < 0) return FR_INVALID_DRIVE;
+	cfs = FatFs[vol];					/* Pointer to fs object */
+
+	if (cfs) {
+#if _FS_LOCK != 0
+		clear_lock(cfs);
+#endif
+#if _FS_REENTRANT						/* Discard sync object of the current volume */
+		if (!ff_del_syncobj(cfs->sobj)) return FR_INT_ERR;
+#endif
+		cfs->fs_type = 0;				/* Clear old fs object */
+	}
+
+	if (fs) {
+		fs->fs_type = 0;				/* Clear new fs object */
+#if _FS_REENTRANT						/* Create sync object for the new volume */
+		if (!ff_cre_syncobj((BYTE)vol, &fs->sobj)) return FR_INT_ERR;
+#endif
+	}
+	FatFs[vol] = fs;					/* Register new fs object */
+
+	if (!fs || opt != 1) return FR_OK;	/* Do not mount now, it will be mounted later */
+
+	res = find_volume(&path, &fs, 0);	/* Force mounted the volume */
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Open or Create a File                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_open (
+	FIL* fp,			/* Pointer to the blank file object */
+	const TCHAR* path,	/* Pointer to the file name */
+	BYTE mode			/* Access mode and file open mode flags */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+#if !_FS_READONLY
+	DWORD dw, cl, bcs, clst, sc;
+	FSIZE_t ofs;
+#endif
+	DEF_NAMBUF
+
+
+	if (!fp) return FR_INVALID_OBJECT;
+
+	/* Get logical drive number */
+	mode &= _FS_READONLY ? FA_READ : FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_CREATE_NEW | FA_OPEN_ALWAYS | FA_OPEN_APPEND | FA_SEEKEND;
+	res = find_volume(&path, &fs, mode);
+	if (res == FR_OK) {
+		dj.obj.fs = fs;
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);	/* Follow the file path */
+#if !_FS_READONLY	/* R/W configuration */
+		if (res == FR_OK) {
+			if (dj.fn[NSFLAG] & NS_NONAME) {	/* Origin directory itself? */
+				res = FR_INVALID_NAME;
+			}
+#if _FS_LOCK != 0
+			else {
+				res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
+			}
+#endif
+		}
+		/* Create or Open a file */
+		if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
+			if (res != FR_OK) {					/* No file, create new */
+				if (res == FR_NO_FILE)			/* There is no file to open, create a new entry */
+#if _FS_LOCK != 0
+					res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
+#else
+					res = dir_register(&dj);
+#endif
+				mode |= FA_CREATE_ALWAYS;		/* File is created */
+			}
+			else {								/* Any object is already existing */
+				if (dj.obj.attr & (AM_RDO | AM_DIR)) {	/* Cannot overwrite it (R/O or DIR) */
+					res = FR_DENIED;
+				} else {
+					if (mode & FA_CREATE_NEW) res = FR_EXIST;	/* Cannot create as new file */
+				}
+			}
+			if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {	/* Truncate it if overwrite mode */
+				dw = GET_FATTIME();
+#if _FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {
+					/* Get current allocation info */
+					fp->obj.fs = fs;
+					fp->obj.sclust = ld_dword(fs->dirbuf + XDIR_FstClus);
+					fp->obj.objsize = ld_qword(fs->dirbuf + XDIR_FileSize);
+					fp->obj.stat = fs->dirbuf[XDIR_GenFlags] & 2;
+					/* Initialize directory entry block */
+					st_dword(fs->dirbuf + XDIR_CrtTime, dw);	/* Set created time */
+					fs->dirbuf[XDIR_CrtTime10] = 0;
+					st_dword(fs->dirbuf + XDIR_ModTime, dw);	/* Set modified time */
+					fs->dirbuf[XDIR_ModTime10] = 0;
+					fs->dirbuf[XDIR_Attr] = AM_ARC;				/* Reset attribute */
+					st_dword(fs->dirbuf + XDIR_FstClus, 0);		/* Reset file allocation info */
+					st_qword(fs->dirbuf + XDIR_FileSize, 0);
+					st_qword(fs->dirbuf + XDIR_ValidFileSize, 0);
+					fs->dirbuf[XDIR_GenFlags] = 1;
+					res = store_xdir(&dj);
+					if (res == FR_OK && fp->obj.sclust) {		/* Remove the cluster chain if exist */
+						res = remove_chain(&fp->obj, fp->obj.sclust, 0);
+						fs->last_clst = fp->obj.sclust - 1;		/* Reuse the cluster hole */
+					}
+				} else
+#endif
+				{
+					/* Clean directory info */
+					st_dword(dj.dir + DIR_CrtTime, dw);	/* Set created time */
+					st_dword(dj.dir + DIR_ModTime, dw);	/* Set modified time */
+					dj.dir[DIR_Attr] = AM_ARC;			/* Reset attribute */
+					cl = ld_clust(fs, dj.dir);			/* Get cluster chain */
+					st_clust(fs, dj.dir, 0);			/* Reset file allocation info */
+					st_dword(dj.dir + DIR_FileSize, 0);
+					fs->wflag = 1;
+
+					if (cl) {							/* Remove the cluster chain if exist */
+						dw = fs->winsect;
+						res = remove_chain(&dj.obj, cl, 0);
+						if (res == FR_OK) {
+							res = move_window(fs, dw);
+							fs->last_clst = cl - 1;		/* Reuse the cluster hole */
+						}
+					}
+				}
+			}
+		}
+		else {	/* Open an existing file */
+			if (res == FR_OK) {					/* Following succeeded */
+				if (dj.obj.attr & AM_DIR) {		/* It is a directory */
+					res = FR_NO_FILE;
+				} else {
+					if ((mode & FA_WRITE) && (dj.obj.attr & AM_RDO)) { /* R/O violation */
+						res = FR_DENIED;
+					}
+				}
+			}
+		}
+		if (res == FR_OK) {
+			if (mode & FA_CREATE_ALWAYS)		/* Set file change flag if created or overwritten */
+				mode |= FA_MODIFIED;
+			fp->dir_sect = fs->winsect;			/* Pointer to the directory entry */
+			fp->dir_ptr = dj.dir;
+#if _FS_LOCK != 0
+			fp->obj.lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
+			if (!fp->obj.lockid) res = FR_INT_ERR;
+#endif
+		}
+#else		/* R/O configuration */
+		if (res == FR_OK) {
+			if (dj.fn[NSFLAG] & NS_NONAME) {	/* Origin directory itself? */
+				res = FR_INVALID_NAME;
+			} else {
+				if (dj.obj.attr & AM_DIR) {		/* It is a directory */
+					res = FR_NO_FILE;
+				}
+			}
+		}
+#endif
+
+		if (res == FR_OK) {
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				fp->obj.sclust = ld_dword(fs->dirbuf + XDIR_FstClus);		/* Get allocation info */
+				fp->obj.objsize = ld_qword(fs->dirbuf + XDIR_FileSize);
+				fp->obj.stat = fs->dirbuf[XDIR_GenFlags] & 2;
+				fp->obj.c_scl = dj.obj.sclust;
+				fp->obj.c_size = ((DWORD)dj.obj.objsize & 0xFFFFFF00) | dj.obj.stat;
+				fp->obj.c_ofs = dj.blk_ofs;
+			} else
+#endif
+			{
+				fp->obj.sclust = ld_clust(fs, dj.dir);				/* Get allocation info */
+				fp->obj.objsize = ld_dword(dj.dir + DIR_FileSize);
+			}
+#if _USE_FASTSEEK
+			fp->cltbl = 0;			/* Disable fast seek mode */
+#endif
+			fp->obj.fs = fs;	 	/* Validate the file object */
+			fp->obj.id = fs->id;
+			fp->flag = mode;		/* Set file access mode */
+			fp->err = 0;			/* Clear error flag */
+			fp->sect = 0;			/* Invalidate current data sector */
+			fp->fptr = 0;			/* Set file pointer top of the file */
+#if !_FS_READONLY
+#if !_FS_TINY
+			mem_set(fp->buf, 0, _MAX_SS);	/* Clear sector buffer */
+#endif
+			if ((mode & FA_SEEKEND) && fp->obj.objsize > 0) {	/* Seek to end of file if FA_OPEN_APPEND is specified */
+				fp->fptr = fp->obj.objsize;			/* Offset to seek */
+				bcs = (DWORD)fs->csize * SS(fs);	/* Cluster size in byte */
+				clst = fp->obj.sclust;				/* Follow the cluster chain */
+				for (ofs = fp->obj.objsize; res == FR_OK && ofs > bcs; ofs -= bcs) {
+					clst = get_fat(&fp->obj, clst);
+					if (clst <= 1) res = FR_INT_ERR;
+					if (clst == 0xFFFFFFFF) res = FR_DISK_ERR;
+				}
+				fp->clust = clst;
+				if (res == FR_OK && ofs % SS(fs)) {	/* Fill sector buffer if not on the sector boundary */
+					if ((sc = clust2sect(fs, clst)) == 0) {
+						res = FR_INT_ERR;
+					} else {
+						fp->sect = sc + (DWORD)(ofs / SS(fs));
+#if !_FS_TINY
+						if (disk_read(fs->drv, fp->buf, fp->sect, 1) != RES_OK) res = FR_DISK_ERR;
+#endif
+					}
+				}
+			}
+#endif
+		}
+
+		FREE_NAMBUF();
+	}
+
+	if (res != FR_OK) fp->obj.fs = 0;	/* Invalidate file object on error */
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read File                                                             */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_read (
+	FIL* fp, 	/* Pointer to the file object */
+	void* buff,	/* Pointer to data buffer */
+	UINT btr,	/* Number of bytes to read */
+	UINT* br	/* Pointer to number of bytes read */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD clst, sect;
+	FSIZE_t remain;
+	UINT rcnt, cc, csect;
+	BYTE *rbuff = (BYTE*)buff;
+
+
+	*br = 0;	/* Clear read byte counter */
+	res = validate(fp, &fs);
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+	if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_DENIED); /* Check access mode */
+	remain = fp->obj.objsize - fp->fptr;
+	if (btr > remain) btr = (UINT)remain;		/* Truncate btr by remaining bytes */
+
+	for ( ;  btr;								/* Repeat until all data read */
+		rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
+		if (fp->fptr % SS(fs) == 0) {			/* On the sector boundary? */
+			csect = (UINT)(fp->fptr / SS(fs) & (fs->csize - 1));	/* Sector offset in the cluster */
+			if (csect == 0) {					/* On the cluster boundary? */
+				if (fp->fptr == 0) {			/* On the top of the file? */
+					clst = fp->obj.sclust;		/* Follow cluster chain from the origin */
+				} else {						/* Middle or end of the file */
+#if _USE_FASTSEEK
+					if (fp->cltbl) {
+						clst = clmt_clust(fp, fp->fptr);	/* Get cluster# from the CLMT */
+					} else
+#endif
+					{
+						clst = get_fat(&fp->obj, fp->clust);	/* Follow cluster chain on the FAT */
+					}
+				}
+				if (clst < 2) ABORT(fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+				fp->clust = clst;				/* Update current cluster */
+			}
+			sect = clust2sect(fs, fp->clust);	/* Get current sector */
+			if (!sect) ABORT(fs, FR_INT_ERR);
+			sect += csect;
+			cc = btr / SS(fs);					/* When remaining bytes >= sector size, */
+			if (cc) {							/* Read maximum contiguous sectors directly */
+				if (csect + cc > fs->csize) {	/* Clip at cluster boundary */
+					cc = fs->csize - csect;
+				}
+				if (disk_read(fs->drv, rbuff, sect, cc) != RES_OK) {
+					ABORT(fs, FR_DISK_ERR);
+				}
+#if !_FS_READONLY && _FS_MINIMIZE <= 2			/* Replace one of the read sectors with cached data if it contains a dirty sector */
+#if _FS_TINY
+				if (fs->wflag && fs->winsect - sect < cc) {
+					mem_cpy(rbuff + ((fs->winsect - sect) * SS(fs)), fs->win, SS(fs));
+				}
+#else
+				if ((fp->flag & FA_DIRTY) && fp->sect - sect < cc) {
+					mem_cpy(rbuff + ((fp->sect - sect) * SS(fs)), fp->buf, SS(fs));
+				}
+#endif
+#endif
+				rcnt = SS(fs) * cc;				/* Number of bytes transferred */
+				continue;
+			}
+#if !_FS_TINY
+			if (fp->sect != sect) {			/* Load data sector if not in cache */
+#if !_FS_READONLY
+				if (fp->flag & FA_DIRTY) {		/* Write-back dirty sector cache */
+					if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+					fp->flag &= ~FA_DIRTY;
+				}
+#endif
+				if (disk_read(fs->drv, fp->buf, sect, 1) != RES_OK)	{	/* Fill sector cache */
+					ABORT(fs, FR_DISK_ERR);
+				}
+			}
+#endif
+			fp->sect = sect;
+		}
+		rcnt = SS(fs) - (UINT)fp->fptr % SS(fs);	/* Number of bytes left in the sector */
+		if (rcnt > btr) rcnt = btr;					/* Clip it by btr if needed */
+#if _FS_TINY
+		if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR);	/* Move sector window */
+		mem_cpy(rbuff, fs->win + fp->fptr % SS(fs), rcnt);	/* Extract partial sector */
+#else
+		mem_cpy(rbuff, fp->buf + fp->fptr % SS(fs), rcnt);	/* Extract partial sector */
+#endif
+	}
+
+	LEAVE_FF(fs, FR_OK);
+}
+
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Write File                                                            */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_write (
+	FIL* fp,			/* Pointer to the file object */
+	const void* buff,	/* Pointer to the data to be written */
+	UINT btw,			/* Number of bytes to write */
+	UINT* bw			/* Pointer to number of bytes written */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD clst, sect;
+	UINT wcnt, cc, csect;
+	const BYTE *wbuff = (const BYTE*)buff;
+
+
+	*bw = 0;	/* Clear write byte counter */
+	res = validate(fp, &fs);
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+	if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+
+	/* Check fptr wrap-around (file size cannot reach 4GiB on FATxx) */
+	if ((!_FS_EXFAT || fs->fs_type != FS_EXFAT) && (DWORD)(fp->fptr + btw) < (DWORD)fp->fptr) {
+		btw = (UINT)(0xFFFFFFFF - (DWORD)fp->fptr);
+	}
+
+	for ( ;  btw;							/* Repeat until all data written */
+		wbuff += wcnt, fp->fptr += wcnt, fp->obj.objsize = (fp->fptr > fp->obj.objsize) ? fp->fptr : fp->obj.objsize, *bw += wcnt, btw -= wcnt) {
+		if (fp->fptr % SS(fs) == 0) {		/* On the sector boundary? */
+			csect = (UINT)(fp->fptr / SS(fs)) & (fs->csize - 1);	/* Sector offset in the cluster */
+			if (csect == 0) {				/* On the cluster boundary? */
+				if (fp->fptr == 0) {		/* On the top of the file? */
+					clst = fp->obj.sclust;	/* Follow from the origin */
+					if (clst == 0) {		/* If no cluster is allocated, */
+						clst = create_chain(&fp->obj, 0);	/* create a new cluster chain */
+					}
+				} else {					/* On the middle or end of the file */
+#if _USE_FASTSEEK
+					if (fp->cltbl) {
+						clst = clmt_clust(fp, fp->fptr);	/* Get cluster# from the CLMT */
+					} else
+#endif
+					{
+						clst = create_chain(&fp->obj, fp->clust);	/* Follow or stretch cluster chain on the FAT */
+					}
+				}
+				if (clst == 0) break;		/* Could not allocate a new cluster (disk full) */
+				if (clst == 1) ABORT(fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+				fp->clust = clst;			/* Update current cluster */
+				if (fp->obj.sclust == 0) fp->obj.sclust = clst;	/* Set start cluster if the first write */
+			}
+#if _FS_TINY
+			if (fs->winsect == fp->sect && sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);	/* Write-back sector cache */
+#else
+			if (fp->flag & FA_DIRTY) {		/* Write-back sector cache */
+				if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				fp->flag &= ~FA_DIRTY;
+			}
+#endif
+			sect = clust2sect(fs, fp->clust);	/* Get current sector */
+			if (!sect) ABORT(fs, FR_INT_ERR);
+			sect += csect;
+			cc = btw / SS(fs);				/* When remaining bytes >= sector size, */
+			if (cc) {						/* Write maximum contiguous sectors directly */
+				if (csect + cc > fs->csize) {	/* Clip at cluster boundary */
+					cc = fs->csize - csect;
+				}
+				if (disk_write(fs->drv, wbuff, sect, cc) != RES_OK) {
+					ABORT(fs, FR_DISK_ERR);
+				}
+#if _FS_MINIMIZE <= 2
+#if _FS_TINY
+				if (fs->winsect - sect < cc) {	/* Refill sector cache if it gets invalidated by the direct write */
+					mem_cpy(fs->win, wbuff + ((fs->winsect - sect) * SS(fs)), SS(fs));
+					fs->wflag = 0;
+				}
+#else
+				if (fp->sect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
+					mem_cpy(fp->buf, wbuff + ((fp->sect - sect) * SS(fs)), SS(fs));
+					fp->flag &= ~FA_DIRTY;
+				}
+#endif
+#endif
+				wcnt = SS(fs) * cc;		/* Number of bytes transferred */
+				continue;
+			}
+#if _FS_TINY
+			if (fp->fptr >= fp->obj.objsize) {	/* Avoid silly cache filling at growing edge */
+				if (sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);
+				fs->winsect = sect;
+			}
+#else
+			if (fp->sect != sect) {		/* Fill sector cache with file data */
+				if (fp->fptr < fp->obj.objsize &&
+					disk_read(fs->drv, fp->buf, sect, 1) != RES_OK) {
+						ABORT(fs, FR_DISK_ERR);
+				}
+			}
+#endif
+			fp->sect = sect;
+		}
+		wcnt = SS(fs) - (UINT)fp->fptr % SS(fs);	/* Number of bytes left in the sector */
+		if (wcnt > btw) wcnt = btw;					/* Clip it by btw if needed */
+#if _FS_TINY
+		if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR);	/* Move sector window */
+		mem_cpy(fs->win + fp->fptr % SS(fs), wbuff, wcnt);	/* Fit data to the sector */
+		fs->wflag = 1;
+#else
+		mem_cpy(fp->buf + fp->fptr % SS(fs), wbuff, wcnt);	/* Fit data to the sector */
+		fp->flag |= FA_DIRTY;
+#endif
+	}
+
+	fp->flag |= FA_MODIFIED;						/* Set file change flag */
+
+	LEAVE_FF(fs, FR_OK);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Synchronize the File                                                  */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_sync (
+	FIL* fp		/* Pointer to the file object */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD tm;
+	BYTE *dir;
+#if _FS_EXFAT
+	DEF_NAMBUF
+#endif
+
+	res = validate(fp, &fs);	/* Check validity of the object */
+	if (res == FR_OK) {
+		if (fp->flag & FA_MODIFIED) {	/* Is there any change to the file? */
+#if !_FS_TINY
+			if (fp->flag & FA_DIRTY) {	/* Write-back cached data if needed */
+				if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) LEAVE_FF(fs, FR_DISK_ERR);
+				fp->flag &= ~FA_DIRTY;
+			}
+#endif
+			/* Update the directory entry */
+			tm = GET_FATTIME();				/* Modified time */
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				res = fill_fat_chain(&fp->obj);	/* Create FAT chain if needed */
+				if (res == FR_OK) {
+					DIR dj;
+
+					INIT_NAMBUF(fs);
+					res = load_obj_dir(&dj, &fp->obj);	/* Load directory entry block */
+					if (res == FR_OK) {
+						fs->dirbuf[XDIR_Attr] |= AM_ARC;				/* Set archive bit */
+						fs->dirbuf[XDIR_GenFlags] = fp->obj.stat | 1;	/* Update file allocation info */
+						st_dword(fs->dirbuf + XDIR_FstClus, fp->obj.sclust);
+						st_qword(fs->dirbuf + XDIR_FileSize, fp->obj.objsize);
+						st_qword(fs->dirbuf + XDIR_ValidFileSize, fp->obj.objsize);
+						st_dword(fs->dirbuf + XDIR_ModTime, tm);		/* Update modified time */
+						fs->dirbuf[XDIR_ModTime10] = 0;
+						st_dword(fs->dirbuf + XDIR_AccTime, 0);
+						res = store_xdir(&dj);	/* Restore it to the directory */
+						if (res == FR_OK) {
+							res = sync_fs(fs);
+							fp->flag &= ~FA_MODIFIED;
+						}
+					}
+					FREE_NAMBUF();
+				}
+			} else
+#endif
+			{
+				res = move_window(fs, fp->dir_sect);
+				if (res == FR_OK) {
+					dir = fp->dir_ptr;
+					dir[DIR_Attr] |= AM_ARC;						/* Set archive bit */
+					st_clust(fp->obj.fs, dir, fp->obj.sclust);		/* Update file allocation info  */
+					st_dword(dir + DIR_FileSize, (DWORD)fp->obj.objsize);	/* Update file size */
+					st_dword(dir + DIR_ModTime, tm);				/* Update modified time */
+					st_word(dir + DIR_LstAccDate, 0);
+					fs->wflag = 1;
+					res = sync_fs(fs);					/* Restore it to the directory */
+					fp->flag &= ~FA_MODIFIED;
+				}
+			}
+		}
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Close File                                                            */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_close (
+	FIL* fp		/* Pointer to the file object to be closed */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+
+#if !_FS_READONLY
+	res = f_sync(fp);					/* Flush cached data */
+	if (res == FR_OK)
+#endif
+	{
+		res = validate(fp, &fs);	/* Lock volume */
+		if (res == FR_OK) {
+#if _FS_LOCK != 0
+			res = dec_lock(fp->obj.lockid);	/* Decrement file open counter */
+			if (res == FR_OK)
+#endif
+			{
+				fp->obj.fs = 0;			/* Invalidate file object */
+			}
+#if _FS_REENTRANT
+			unlock_fs(fs, FR_OK);		/* Unlock volume */
+#endif
+		}
+	}
+	return res;
+}
+
+
+
+
+#if _FS_RPATH >= 1
+/*-----------------------------------------------------------------------*/
+/* Change Current Directory or Current Drive, Get Current Directory      */
+/*-----------------------------------------------------------------------*/
+
+#if _VOLUMES >= 2
+FRESULT f_chdrive (
+	const TCHAR* path		/* Drive number */
+)
+{
+	int vol;
+
+
+	vol = get_ldnumber(&path);
+	if (vol < 0) return FR_INVALID_DRIVE;
+
+	CurrVol = (BYTE)vol;
+
+	return FR_OK;
+}
+#endif
+
+
+FRESULT f_chdir (
+	const TCHAR* path	/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	DEF_NAMBUF
+
+	/* Get logical drive number */
+	res = find_volume(&path, &fs, 0);
+	if (res == FR_OK) {
+		dj.obj.fs = fs;
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);		/* Follow the path */
+		if (res == FR_OK) {					/* Follow completed */
+			if (dj.fn[NSFLAG] & NS_NONAME) {
+				fs->cdir = dj.obj.sclust;	/* It is the start directory itself */
+#if _FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {
+					fs->cdc_scl = dj.obj.c_scl;
+					fs->cdc_size = dj.obj.c_size;
+					fs->cdc_ofs = dj.obj.c_ofs;
+				}
+#endif
+			} else {
+				if (dj.obj.attr & AM_DIR) {	/* It is a sub-directory */
+#if _FS_EXFAT
+					if (fs->fs_type == FS_EXFAT) {
+						fs->cdir = ld_dword(fs->dirbuf + XDIR_FstClus);		/* Sub-directory cluster */
+						fs->cdc_scl = dj.obj.sclust;						/* Save containing directory information */
+						fs->cdc_size = ((DWORD)dj.obj.objsize & 0xFFFFFF00) | dj.obj.stat;
+						fs->cdc_ofs = dj.blk_ofs;
+					} else
+#endif
+					{
+						fs->cdir = ld_clust(fs, dj.dir);					/* Sub-directory cluster */
+					}
+				} else {
+					res = FR_NO_PATH;		/* Reached but a file */
+				}
+			}
+		}
+		FREE_NAMBUF();
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+#if _FS_RPATH >= 2
+FRESULT f_getcwd (
+	TCHAR* buff,	/* Pointer to the directory path */
+	UINT len		/* Size of path */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	UINT i, n;
+	DWORD ccl;
+	TCHAR *tp;
+	FILINFO fno;
+	DEF_NAMBUF
+
+
+	*buff = 0;
+	/* Get logical drive number */
+	res = find_volume((const TCHAR**)&buff, &fs, 0);	/* Get current volume */
+	if (res == FR_OK) {
+		dj.obj.fs = fs;
+		INIT_NAMBUF(fs);
+		i = len;			/* Bottom of buffer (directory stack base) */
+		if (!_FS_EXFAT || fs->fs_type != FS_EXFAT) {	/* (Cannot do getcwd on exFAT and returns root path) */
+			dj.obj.sclust = fs->cdir;				/* Start to follow upper directory from current directory */
+			while ((ccl = dj.obj.sclust) != 0) {	/* Repeat while current directory is a sub-directory */
+				res = dir_sdi(&dj, 1 * SZDIRE);	/* Get parent directory */
+				if (res != FR_OK) break;
+				res = move_window(fs, dj.sect);
+				if (res != FR_OK) break;
+				dj.obj.sclust = ld_clust(fs, dj.dir);	/* Goto parent directory */
+				res = dir_sdi(&dj, 0);
+				if (res != FR_OK) break;
+				do {							/* Find the entry links to the child directory */
+					res = dir_read(&dj, 0);
+					if (res != FR_OK) break;
+					if (ccl == ld_clust(fs, dj.dir)) break;	/* Found the entry */
+					res = dir_next(&dj, 0);
+				} while (res == FR_OK);
+				if (res == FR_NO_FILE) res = FR_INT_ERR;/* It cannot be 'not found'. */
+				if (res != FR_OK) break;
+				get_fileinfo(&dj, &fno);		/* Get the directory name and push it to the buffer */
+				for (n = 0; fno.fname[n]; n++) ;
+				if (i < n + 3) {
+					res = FR_NOT_ENOUGH_CORE; break;
+				}
+				while (n) buff[--i] = fno.fname[--n];
+				buff[--i] = '/';
+			}
+		}
+		tp = buff;
+		if (res == FR_OK) {
+#if _VOLUMES >= 2
+			*tp++ = '0' + CurrVol;			/* Put drive number */
+			*tp++ = ':';
+#endif
+			if (i == len) {					/* Root-directory */
+				*tp++ = '/';
+			} else {						/* Sub-directroy */
+				do		/* Add stacked path str */
+					*tp++ = buff[i++];
+				while (i < len);
+			}
+		}
+		*tp = 0;
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif /* _FS_RPATH >= 2 */
+#endif /* _FS_RPATH >= 1 */
+
+
+
+#if _FS_MINIMIZE <= 2
+/*-----------------------------------------------------------------------*/
+/* Seek File R/W Pointer                                                 */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_lseek (
+	FIL* fp,		/* Pointer to the file object */
+	FSIZE_t ofs		/* File pointer from top of file */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD clst, bcs, nsect;
+	FSIZE_t ifptr;
+#if _USE_FASTSEEK
+	DWORD cl, pcl, ncl, tcl, dsc, tlen, ulen, *tbl;
+#endif
+
+	res = validate(fp, &fs);		/* Check validity of the object */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+#if _USE_FASTSEEK
+	if (fp->cltbl) {	/* Fast seek */
+		if (ofs == CREATE_LINKMAP) {	/* Create CLMT */
+			tbl = fp->cltbl;
+			tlen = *tbl++; ulen = 2;	/* Given table size and required table size */
+			cl = fp->obj.sclust;		/* Origin of the chain */
+			if (cl) {
+				do {
+					/* Get a fragment */
+					tcl = cl; ncl = 0; ulen += 2;	/* Top, length and used items */
+					do {
+						pcl = cl; ncl++;
+						cl = get_fat(&fp->obj, cl);
+						if (cl <= 1) ABORT(fs, FR_INT_ERR);
+						if (cl == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+					} while (cl == pcl + 1);
+					if (ulen <= tlen) {		/* Store the length and top of the fragment */
+						*tbl++ = ncl; *tbl++ = tcl;
+					}
+				} while (cl < fs->n_fatent);	/* Repeat until end of chain */
+			}
+			*fp->cltbl = ulen;	/* Number of items used */
+			if (ulen <= tlen) {
+				*tbl = 0;		/* Terminate table */
+			} else {
+				res = FR_NOT_ENOUGH_CORE;	/* Given table size is smaller than required */
+			}
+		} else {						/* Fast seek */
+			if (ofs > fp->obj.objsize) ofs = fp->obj.objsize;	/* Clip offset at the file size */
+			fp->fptr = ofs;				/* Set file pointer */
+			if (ofs) {
+				fp->clust = clmt_clust(fp, ofs - 1);
+				dsc = clust2sect(fs, fp->clust);
+				if (!dsc) ABORT(fs, FR_INT_ERR);
+				dsc += (DWORD)((ofs - 1) / SS(fs)) & (fs->csize - 1);
+				if (fp->fptr % SS(fs) && dsc != fp->sect) {	/* Refill sector cache if needed */
+#if !_FS_TINY
+#if !_FS_READONLY
+					if (fp->flag & FA_DIRTY) {		/* Write-back dirty sector cache */
+						if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+						fp->flag &= ~FA_DIRTY;
+					}
+#endif
+					if (disk_read(fs->drv, fp->buf, dsc, 1) != RES_OK) {	/* Load current sector */
+						ABORT(fs, FR_DISK_ERR);
+					}
+#endif
+					fp->sect = dsc;
+				}
+			}
+		}
+	} else
+#endif
+
+	/* Normal Seek */
+	{
+#if _FS_EXFAT
+		if (fs->fs_type != FS_EXFAT && ofs >= 0x100000000) ofs = 0xFFFFFFFF;	/* Clip at 4GiB-1 if at FATxx */
+#endif
+		if (ofs > fp->obj.objsize && (_FS_READONLY || !(fp->flag & FA_WRITE))) {	/* In read-only mode, clip offset with the file size */
+			ofs = fp->obj.objsize;
+		}
+		ifptr = fp->fptr;
+		fp->fptr = nsect = 0;
+		if (ofs) {
+			bcs = (DWORD)fs->csize * SS(fs);	/* Cluster size (byte) */
+			if (ifptr > 0 &&
+				(ofs - 1) / bcs >= (ifptr - 1) / bcs) {	/* When seek to same or following cluster, */
+				fp->fptr = (ifptr - 1) & ~(bcs - 1);	/* start from the current cluster */
+				ofs -= fp->fptr;
+				clst = fp->clust;
+			} else {									/* When seek to back cluster, */
+				clst = fp->obj.sclust;					/* start from the first cluster */
+#if !_FS_READONLY
+				if (clst == 0) {						/* If no cluster chain, create a new chain */
+					clst = create_chain(&fp->obj, 0);
+					if (clst == 1) ABORT(fs, FR_INT_ERR);
+					if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+					fp->obj.sclust = clst;
+				}
+#endif
+				fp->clust = clst;
+			}
+			if (clst != 0) {
+				while (ofs > bcs) {						/* Cluster following loop */
+					ofs -= bcs; fp->fptr += bcs;
+#if !_FS_READONLY
+					if (fp->flag & FA_WRITE) {			/* Check if in write mode or not */
+						if (_FS_EXFAT && fp->fptr > fp->obj.objsize) {	/* No FAT chain object needs correct objsize to generate FAT value */
+							fp->obj.objsize = fp->fptr;
+							fp->flag |= FA_MODIFIED;
+						}
+						clst = create_chain(&fp->obj, clst);	/* Force stretch if in write mode */
+						if (clst == 0) {				/* When disk gets full, clip file size */
+							ofs = 0; break;
+						}
+					} else
+#endif
+						clst = get_fat(&fp->obj, clst);	/* Follow cluster chain if not in write mode */
+					if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+					if (clst <= 1 || clst >= fs->n_fatent) ABORT(fs, FR_INT_ERR);
+					fp->clust = clst;
+				}
+				fp->fptr += ofs;
+				if (ofs % SS(fs)) {
+					nsect = clust2sect(fs, clst);	/* Current sector */
+					if (!nsect) ABORT(fs, FR_INT_ERR);
+					nsect += (DWORD)(ofs / SS(fs));
+				}
+			}
+		}
+		if (fp->fptr % SS(fs) && nsect != fp->sect) {	/* Fill sector cache if needed */
+#if !_FS_TINY
+#if !_FS_READONLY
+			if (fp->flag & FA_DIRTY) {			/* Write-back dirty sector cache */
+				if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				fp->flag &= ~FA_DIRTY;
+			}
+#endif
+			if (disk_read(fs->drv, fp->buf, nsect, 1) != RES_OK) {	/* Fill sector cache */
+				ABORT(fs, FR_DISK_ERR);
+			}
+#endif
+			fp->sect = nsect;
+		}
+#if !_FS_READONLY
+		if (fp->fptr > fp->obj.objsize) {		/* Set file change flag if the file size is extended */
+			fp->obj.objsize = fp->fptr;
+			fp->flag |= FA_MODIFIED;
+		}
+#endif
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+#if _FS_MINIMIZE <= 1
+/*-----------------------------------------------------------------------*/
+/* Create a Directory Object                                             */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_opendir (
+	DIR* dp,			/* Pointer to directory object to create */
+	const TCHAR* path	/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	_FDID *obj;
+	DEF_NAMBUF
+
+
+	if (!dp) return FR_INVALID_OBJECT;
+
+	/* Get logical drive number */
+	obj = &dp->obj;
+	res = find_volume(&path, &fs, 0);
+	if (res == FR_OK) {
+		obj->fs = fs;
+		INIT_NAMBUF(fs);
+		res = follow_path(dp, path);			/* Follow the path to the directory */
+		if (res == FR_OK) {						/* Follow completed */
+			if (!(dp->fn[NSFLAG] & NS_NONAME)) {	/* It is not the origin directory itself */
+				if (obj->attr & AM_DIR) {		/* This object is a sub-directory */
+#if _FS_EXFAT
+					if (fs->fs_type == FS_EXFAT) {
+						obj->c_scl = obj->sclust;	/* Save containing directory inforamation */
+						obj->c_size = ((DWORD)obj->objsize & 0xFFFFFF00) | obj->stat;
+						obj->c_ofs = dp->blk_ofs;
+						obj->sclust = ld_dword(fs->dirbuf + XDIR_FstClus);	/* Get object location and status */
+						obj->objsize = ld_qword(fs->dirbuf + XDIR_FileSize);
+						obj->stat = fs->dirbuf[XDIR_GenFlags] & 2;
+					} else
+#endif
+					{
+						obj->sclust = ld_clust(fs, dp->dir);	/* Get object location */
+					}
+				} else {						/* This object is a file */
+					res = FR_NO_PATH;
+				}
+			}
+			if (res == FR_OK) {
+				obj->id = fs->id;
+				res = dir_sdi(dp, 0);			/* Rewind directory */
+#if _FS_LOCK != 0
+				if (res == FR_OK) {
+					if (obj->sclust) {
+						obj->lockid = inc_lock(dp, 0);	/* Lock the sub directory */
+						if (!obj->lockid) res = FR_TOO_MANY_OPEN_FILES;
+					} else {
+						obj->lockid = 0;	/* Root directory need not to be locked */
+					}
+				}
+#endif
+			}
+		}
+		FREE_NAMBUF();
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+	if (res != FR_OK) obj->fs = 0;		/* Invalidate the directory object if function faild */
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Close Directory                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_closedir (
+	DIR *dp		/* Pointer to the directory object to be closed */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+
+
+	res = validate(dp, &fs);
+	if (res == FR_OK) {
+#if _FS_LOCK != 0
+		if (dp->obj.lockid) {				/* Decrement sub-directory open counter */
+			res = dec_lock(dp->obj.lockid);
+		}
+		if (res == FR_OK)
+#endif
+		{
+			dp->obj.fs = 0;			/* Invalidate directory object */
+		}
+#if _FS_REENTRANT
+		unlock_fs(fs, FR_OK);		/* Unlock volume */
+#endif
+	}
+	return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Directory Entries in Sequence                                    */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_readdir (
+	DIR* dp,			/* Pointer to the open directory object */
+	FILINFO* fno		/* Pointer to file information to return */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DEF_NAMBUF
+
+
+	res = validate(dp, &fs);	/* Check validity of the object */
+	if (res == FR_OK) {
+		if (!fno) {
+			res = dir_sdi(dp, 0);			/* Rewind the directory object */
+		} else {
+			INIT_NAMBUF(fs);
+			res = dir_read(dp, 0);			/* Read an item */
+			if (res == FR_NO_FILE) res = FR_OK;	/* Ignore end of directory */
+			if (res == FR_OK) {				/* A valid entry is found */
+				get_fileinfo(dp, fno);		/* Get the object information */
+				res = dir_next(dp, 0);		/* Increment index for next */
+				if (res == FR_NO_FILE) res = FR_OK;	/* Ignore end of directory now */
+			}
+			FREE_NAMBUF();
+		}
+	}
+	LEAVE_FF(fs, res);
+}
+
+
+
+#if _USE_FIND
+/*-----------------------------------------------------------------------*/
+/* Find Next File                                                        */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_findnext (
+	DIR* dp,		/* Pointer to the open directory object */
+	FILINFO* fno	/* Pointer to the file information structure */
+)
+{
+	FRESULT res;
+
+
+	for (;;) {
+		res = f_readdir(dp, fno);		/* Get a directory item */
+		if (res != FR_OK || !fno || !fno->fname[0]) break;	/* Terminate if any error or end of directory */
+		if (pattern_matching(dp->pat, fno->fname, 0, 0)) break;		/* Test for the file name */
+#if _USE_LFN != 0 && _USE_FIND == 2
+		if (pattern_matching(dp->pat, fno->altname, 0, 0)) break;	/* Test for alternative name if exist */
+#endif
+	}
+	return res;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Find First File                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_findfirst (
+	DIR* dp,				/* Pointer to the blank directory object */
+	FILINFO* fno,			/* Pointer to the file information structure */
+	const TCHAR* path,		/* Pointer to the directory to open */
+	const TCHAR* pattern	/* Pointer to the matching pattern */
+)
+{
+	FRESULT res;
+
+
+	dp->pat = pattern;		/* Save pointer to pattern string */
+	res = f_opendir(dp, path);		/* Open the target directory */
+	if (res == FR_OK) {
+		res = f_findnext(dp, fno);	/* Find the first item */
+	}
+	return res;
+}
+
+#endif	/* _USE_FIND */
+
+
+
+#if _FS_MINIMIZE == 0
+/*-----------------------------------------------------------------------*/
+/* Get File Status                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_stat (
+	const TCHAR* path,	/* Pointer to the file path */
+	FILINFO* fno		/* Pointer to file information to return */
+)
+{
+	FRESULT res;
+	DIR dj;
+	DEF_NAMBUF
+
+
+	/* Get logical drive number */
+	res = find_volume(&path, &dj.obj.fs, 0);
+	if (res == FR_OK) {
+		INIT_NAMBUF(dj.obj.fs);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (res == FR_OK) {				/* Follow completed */
+			if (dj.fn[NSFLAG] & NS_NONAME) {	/* It is origin directory */
+				res = FR_INVALID_NAME;
+			} else {							/* Found an object */
+				if (fno) get_fileinfo(&dj, fno);
+			}
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(dj.obj.fs, res);
+}
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Get Number of Free Clusters                                           */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_getfree (
+	const TCHAR* path,	/* Path name of the logical drive number */
+	DWORD* nclst,		/* Pointer to a variable to return number of free clusters */
+	FATFS** fatfs		/* Pointer to return pointer to corresponding file system object */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD nfree, clst, sect, stat;
+	UINT i;
+	BYTE *p;
+	_FDID obj;
+
+
+	/* Get logical drive number */
+	res = find_volume(&path, &fs, 0);
+	if (res == FR_OK) {
+		*fatfs = fs;				/* Return ptr to the fs object */
+		/* If free_clst is valid, return it without full cluster scan */
+		if (fs->free_clst <= fs->n_fatent - 2) {
+			*nclst = fs->free_clst;
+		} else {
+			/* Get number of free clusters */
+			nfree = 0;
+			if (fs->fs_type == FS_FAT12) {	/* FAT12: Sector unalighed FAT entries */
+				clst = 2; obj.fs = fs;
+				do {
+					stat = get_fat(&obj, clst);
+					if (stat == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
+					if (stat == 1) { res = FR_INT_ERR; break; }
+					if (stat == 0) nfree++;
+				} while (++clst < fs->n_fatent);
+			} else {
+#if _FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {	/* exFAT: Scan bitmap table */
+					BYTE bm;
+					UINT b;
+
+					clst = fs->n_fatent - 2;
+					sect = fs->database;
+					i = 0;
+					do {
+						if (i == 0 && (res = move_window(fs, sect++)) != FR_OK) break;
+						for (b = 8, bm = fs->win[i]; b && clst; b--, clst--) {
+							if (!(bm & 1)) nfree++;
+							bm >>= 1;
+						}
+						i = (i + 1) % SS(fs);
+					} while (clst);
+				} else
+#endif
+				{	/* FAT16/32: Sector alighed FAT entries */
+					clst = fs->n_fatent; sect = fs->fatbase;
+					i = 0; p = 0;
+					do {
+						if (i == 0) {
+							res = move_window(fs, sect++);
+							if (res != FR_OK) break;
+							p = fs->win;
+							i = SS(fs);
+						}
+						if (fs->fs_type == FS_FAT16) {
+							if (ld_word(p) == 0) nfree++;
+							p += 2; i -= 2;
+						} else {
+							if ((ld_dword(p) & 0x0FFFFFFF) == 0) nfree++;
+							p += 4; i -= 4;
+						}
+					} while (--clst);
+				}
+			}
+			*nclst = nfree;			/* Return the free clusters */
+			fs->free_clst = nfree;	/* Now free_clst is valid */
+			fs->fsi_flag |= 1;		/* FSInfo is to be updated */
+		}
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Truncate File                                                         */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_truncate (
+	FIL* fp		/* Pointer to the file object */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD ncl;
+
+
+	res = validate(fp, &fs);	/* Check validity of the object */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+	if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+
+	if (fp->obj.objsize > fp->fptr) {
+		if (fp->fptr == 0) {	/* When set file size to zero, remove entire cluster chain */
+			res = remove_chain(&fp->obj, fp->obj.sclust, 0);
+			fp->obj.sclust = 0;
+		} else {				/* When truncate a part of the file, remove remaining clusters */
+			ncl = get_fat(&fp->obj, fp->clust);
+			res = FR_OK;
+			if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
+			if (ncl == 1) res = FR_INT_ERR;
+			if (res == FR_OK && ncl < fs->n_fatent) {
+				res = remove_chain(&fp->obj, ncl, fp->clust);
+			}
+		}
+		fp->obj.objsize = fp->fptr;	/* Set file size to current R/W point */
+		fp->flag |= FA_MODIFIED;
+#if !_FS_TINY
+		if (res == FR_OK && (fp->flag & FA_DIRTY)) {
+			if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) {
+				res = FR_DISK_ERR;
+			} else {
+				fp->flag &= ~FA_DIRTY;
+			}
+		}
+#endif
+		if (res != FR_OK) ABORT(fs, res);
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Delete a File/Directory                                               */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_unlink (
+	const TCHAR* path		/* Pointer to the file or directory path */
+)
+{
+	FRESULT res;
+	DIR dj, sdj;
+	DWORD dclst = 0;
+	FATFS *fs;
+#if _FS_EXFAT
+	_FDID obj;
+#endif
+	DEF_NAMBUF
+
+
+	/* Get logical drive number */
+	res = find_volume(&path, &fs, FA_WRITE);
+	dj.obj.fs = fs;
+	if (res == FR_OK) {
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);		/* Follow the file path */
+		if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT)) {
+			res = FR_INVALID_NAME;			/* Cannot remove dot entry */
+		}
+#if _FS_LOCK != 0
+		if (res == FR_OK) res = chk_lock(&dj, 2);	/* Check if it is an open object */
+#endif
+		if (res == FR_OK) {					/* The object is accessible */
+			if (dj.fn[NSFLAG] & NS_NONAME) {
+				res = FR_INVALID_NAME;		/* Cannot remove the origin directory */
+			} else {
+				if (dj.obj.attr & AM_RDO) {
+					res = FR_DENIED;		/* Cannot remove R/O object */
+				}
+			}
+			if (res == FR_OK) {
+#if _FS_EXFAT
+				obj.fs = fs;
+				if (fs->fs_type == FS_EXFAT) {
+					obj.sclust = dclst = ld_dword(fs->dirbuf + XDIR_FstClus);
+					obj.objsize = ld_qword(fs->dirbuf + XDIR_FileSize);
+					obj.stat = fs->dirbuf[XDIR_GenFlags] & 2;
+				} else
+#endif
+				{
+					dclst = ld_clust(fs, dj.dir);
+				}
+				if (dj.obj.attr & AM_DIR) {			/* Is it a sub-directory ? */
+#if _FS_RPATH != 0
+					if (dclst == fs->cdir) {		 		/* Is it the current directory? */
+						res = FR_DENIED;
+					} else
+#endif
+					{
+						sdj.obj.fs = fs;						/* Open the sub-directory */
+						sdj.obj.sclust = dclst;
+#if _FS_EXFAT
+						if (fs->fs_type == FS_EXFAT) {
+							sdj.obj.objsize = obj.objsize;
+							sdj.obj.stat = obj.stat;
+						}
+#endif
+						res = dir_sdi(&sdj, 0);
+						if (res == FR_OK) {
+							res = dir_read(&sdj, 0);			/* Read an item */
+							if (res == FR_OK) res = FR_DENIED;	/* Not empty? */
+							if (res == FR_NO_FILE) res = FR_OK;	/* Empty? */
+						}
+					}
+				}
+			}
+			if (res == FR_OK) {
+				res = dir_remove(&dj);			/* Remove the directory entry */
+				if (res == FR_OK && dclst) {	/* Remove the cluster chain if exist */
+#if _FS_EXFAT
+					res = remove_chain(&obj, dclst, 0);
+#else
+					res = remove_chain(&dj.obj, dclst, 0);
+#endif
+				}
+				if (res == FR_OK) res = sync_fs(fs);
+			}
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create a Directory                                                    */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mkdir (
+	const TCHAR* path		/* Pointer to the directory path */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	BYTE *dir;
+	UINT n;
+	DWORD dsc, dcl, pcl, tm;
+	DEF_NAMBUF
+
+
+	/* Get logical drive number */
+	res = find_volume(&path, &fs, FA_WRITE);
+	dj.obj.fs = fs;
+	if (res == FR_OK) {
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);			/* Follow the file path */
+		if (res == FR_OK) res = FR_EXIST;		/* Any object with same name is already existing */
+		if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NSFLAG] & NS_DOT)) {
+			res = FR_INVALID_NAME;
+		}
+		if (res == FR_NO_FILE) {				/* Can create a new directory */
+			dcl = create_chain(&dj.obj, 0);		/* Allocate a cluster for the new directory table */
+			dj.obj.objsize = (DWORD)fs->csize * SS(fs);
+			res = FR_OK;
+			if (dcl == 0) res = FR_DENIED;		/* No space to allocate a new cluster */
+			if (dcl == 1) res = FR_INT_ERR;
+			if (dcl == 0xFFFFFFFF) res = FR_DISK_ERR;
+			if (res == FR_OK) res = sync_window(fs);	/* Flush FAT */
+			tm = GET_FATTIME();
+			if (res == FR_OK) {					/* Initialize the new directory table */
+				dsc = clust2sect(fs, dcl);
+				dir = fs->win;
+				mem_set(dir, 0, SS(fs));
+				if (!_FS_EXFAT || fs->fs_type != FS_EXFAT) {
+					mem_set(dir + DIR_Name, ' ', 11);	/* Create "." entry */
+					dir[DIR_Name] = '.';
+					dir[DIR_Attr] = AM_DIR;
+					st_dword(dir + DIR_ModTime, tm);
+					st_clust(fs, dir, dcl);
+					mem_cpy(dir + SZDIRE, dir, SZDIRE); 	/* Create ".." entry */
+					dir[SZDIRE + 1] = '.'; pcl = dj.obj.sclust;
+					if (fs->fs_type == FS_FAT32 && pcl == fs->dirbase) pcl = 0;
+					st_clust(fs, dir + SZDIRE, pcl);
+				}
+				for (n = fs->csize; n; n--) {	/* Write dot entries and clear following sectors */
+					fs->winsect = dsc++;
+					fs->wflag = 1;
+					res = sync_window(fs);
+					if (res != FR_OK) break;
+					mem_set(dir, 0, SS(fs));
+				}
+			}
+			if (res == FR_OK) res = dir_register(&dj);	/* Register the object to the directoy */
+			if (res == FR_OK) {
+#if _FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {	/* Initialize directory entry block */
+					st_dword(fs->dirbuf + XDIR_ModTime, tm);	/* Created time */
+					st_dword(fs->dirbuf + XDIR_FstClus, dcl);	/* Table start cluster */
+					st_dword(fs->dirbuf + XDIR_FileSize, (DWORD)dj.obj.objsize);	/* File size needs to be valid */
+					st_dword(fs->dirbuf + XDIR_ValidFileSize, (DWORD)dj.obj.objsize);
+					fs->dirbuf[XDIR_GenFlags] = 3;				/* Initialize the object flag (contiguous) */
+					fs->dirbuf[XDIR_Attr] = AM_DIR;				/* Attribute */
+					res = store_xdir(&dj);
+				} else
+#endif
+				{
+					dir = dj.dir;
+					st_dword(dir + DIR_ModTime, tm);	/* Created time */
+					st_clust(fs, dir, dcl);				/* Table start cluster */
+					dir[DIR_Attr] = AM_DIR;				/* Attribute */
+					fs->wflag = 1;
+				}
+				if (res == FR_OK) res = sync_fs(fs);
+			} else {
+				remove_chain(&dj.obj, dcl, 0);		/* Could not register, remove cluster chain */
+			}
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Rename a File/Directory                                               */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_rename (
+	const TCHAR* path_old,	/* Pointer to the object name to be renamed */
+	const TCHAR* path_new	/* Pointer to the new name */
+)
+{
+	FRESULT res;
+	DIR djo, djn;
+	FATFS *fs;
+	BYTE buf[_FS_EXFAT ? SZDIRE * 2 : 24], *dir;
+	DWORD dw;
+	DEF_NAMBUF
+
+
+	get_ldnumber(&path_new);						/* Ignore drive number of new name */
+	res = find_volume(&path_old, &fs, FA_WRITE);	/* Get logical drive number of the old object */
+	if (res == FR_OK) {
+		djo.obj.fs = fs;
+		INIT_NAMBUF(fs);
+		res = follow_path(&djo, path_old);		/* Check old object */
+		if (res == FR_OK && (djo.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;	/* Check validity of name */
+#if _FS_LOCK != 0
+		if (res == FR_OK) res = chk_lock(&djo, 2);
+#endif
+		if (res == FR_OK) {						/* Object to be renamed is found */
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {	/* At exFAT */
+				BYTE nf, nn;
+				WORD nh;
+
+				mem_cpy(buf, fs->dirbuf, SZDIRE * 2);	/* Save 85+C0 entry of old object */
+				mem_cpy(&djn, &djo, sizeof djo);
+				res = follow_path(&djn, path_new);	/* Make sure if new object name is not in use */
+				if (res == FR_OK) res = FR_EXIST;	/* Is new name already in use? */
+				if (res == FR_NO_FILE) { 			/* It is a valid path and no name collision */
+					res = dir_register(&djn);		/* Register the new entry */
+					if (res == FR_OK) {
+						nf = fs->dirbuf[XDIR_NumSec]; nn = fs->dirbuf[XDIR_NumName];
+						nh = ld_word(fs->dirbuf + XDIR_NameHash);
+						mem_cpy(fs->dirbuf, buf, SZDIRE * 2);
+						fs->dirbuf[XDIR_NumSec] = nf; fs->dirbuf[XDIR_NumName] = nn;
+						st_word(fs->dirbuf + XDIR_NameHash, nh);
+/* Start of critical section where any interruption can cause a cross-link */
+						res = store_xdir(&djn);
+					}
+				}
+			} else
+#endif
+			{	/* At FAT12/FAT16/FAT32 */
+				mem_cpy(buf, djo.dir + DIR_Attr, 21);	/* Save information about the object except name */
+				mem_cpy(&djn, &djo, sizeof (DIR));		/* Duplicate the directory object */
+				res = follow_path(&djn, path_new);		/* Make sure if new object name is not in use */
+				if (res == FR_OK) res = FR_EXIST;		/* Is new name already in use? */
+				if (res == FR_NO_FILE) { 				/* It is a valid path and no name collision */
+					res = dir_register(&djn);			/* Register the new entry */
+					if (res == FR_OK) {
+						dir = djn.dir;					/* Copy information about object except name */
+						mem_cpy(dir + 13, buf + 2, 19);
+						dir[DIR_Attr] = buf[0] | AM_ARC;
+						fs->wflag = 1;
+						if ((dir[DIR_Attr] & AM_DIR) && djo.obj.sclust != djn.obj.sclust) {	/* Update .. entry in the sub-directory if needed */
+							dw = clust2sect(fs, ld_clust(fs, dir));
+							if (!dw) {
+								res = FR_INT_ERR;
+							} else {
+/* Start of critical section where any interruption can cause a cross-link */
+								res = move_window(fs, dw);
+								dir = fs->win + SZDIRE * 1;	/* Ptr to .. entry */
+								if (res == FR_OK && dir[1] == '.') {
+									st_clust(fs, dir, djn.obj.sclust);
+									fs->wflag = 1;
+								}
+							}
+						}
+					}
+				}
+			}
+			if (res == FR_OK) {
+				res = dir_remove(&djo);		/* Remove old entry */
+				if (res == FR_OK) {
+					res = sync_fs(fs);
+				}
+			}
+/* End of critical section */
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _FS_MINIMIZE == 0 */
+#endif /* _FS_MINIMIZE <= 1 */
+#endif /* _FS_MINIMIZE <= 2 */
+
+
+
+#if _USE_CHMOD && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Change Attribute                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_chmod (
+	const TCHAR* path,	/* Pointer to the file path */
+	BYTE attr,			/* Attribute bits */
+	BYTE mask			/* Attribute mask to change */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	DEF_NAMBUF
+
+
+	res = find_volume(&path, &fs, FA_WRITE);	/* Get logical drive number */
+	dj.obj.fs = fs;
+	if (res == FR_OK) {
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (res == FR_OK && (dj.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;	/* Check object validity */
+		if (res == FR_OK) {
+			mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;	/* Valid attribute mask */
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				fs->dirbuf[XDIR_Attr] = (attr & mask) | (fs->dirbuf[XDIR_Attr] & (BYTE)~mask);	/* Apply attribute change */
+				res = store_xdir(&dj);
+			} else
+#endif
+			{
+				dj.dir[DIR_Attr] = (attr & mask) | (dj.dir[DIR_Attr] & (BYTE)~mask);	/* Apply attribute change */
+				fs->wflag = 1;
+			}
+			if (res == FR_OK) res = sync_fs(fs);
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Change Timestamp                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_utime (
+	const TCHAR* path,	/* Pointer to the file/directory name */
+	const FILINFO* fno	/* Pointer to the time stamp to be set */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	DEF_NAMBUF
+
+
+	res = find_volume(&path, &fs, FA_WRITE);	/* Get logical drive number */
+	dj.obj.fs = fs;
+	if (res == FR_OK) {
+		INIT_NAMBUF(fs);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (res == FR_OK && (dj.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;	/* Check object validity */
+		if (res == FR_OK) {
+#if _FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				st_dword(fs->dirbuf + XDIR_ModTime, (DWORD)fno->fdate << 16 | fno->ftime);
+				res = store_xdir(&dj);
+			} else
+#endif
+			{
+				st_dword(dj.dir + DIR_ModTime, (DWORD)fno->fdate << 16 | fno->ftime);
+				fs->wflag = 1;
+			}
+			if (res == FR_OK) res = sync_fs(fs);
+		}
+		FREE_NAMBUF();
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif	/* _USE_CHMOD && !_FS_READONLY */
+
+
+
+#if _USE_LABEL
+/*-----------------------------------------------------------------------*/
+/* Get Volume Label                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_getlabel (
+	const TCHAR* path,	/* Path name of the logical drive number */
+	TCHAR* label,		/* Pointer to a buffer to return the volume label */
+	DWORD* vsn			/* Pointer to a variable to return the volume serial number */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	UINT si, di;
+#if _LFN_UNICODE || _FS_EXFAT
+	WCHAR w;
+#endif
+
+	/* Get logical drive number */
+	res = find_volume(&path, &fs, 0);
+
+	/* Get volume label */
+	if (res == FR_OK && label) {
+		dj.obj.fs = fs; dj.obj.sclust = 0;	/* Open root directory */
+		res = dir_sdi(&dj, 0);
+		if (res == FR_OK) {
+		 	res = dir_read(&dj, 1);			/* Find a volume label entry */
+		 	if (res == FR_OK) {
+#if _FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {
+					for (si = di = 0; si < dj.dir[XDIR_NumLabel]; si++) {	/* Extract volume label from 83 entry */
+						w = ld_word(dj.dir + XDIR_Label + si * 2);
+#if _LFN_UNICODE
+						label[di++] = w;
+#else
+						w = ff_convert(w, 0);	/* Unicode -> OEM */
+						if (w == 0) w = '?';	/* Replace wrong character */
+						if (_DF1S && w >= 0x100) label[di++] = (char)(w >> 8);
+						label[di++] = (char)w;
+#endif
+					}
+					label[di] = 0;
+				} else
+#endif
+				{
+					si = di = 0;		/* Extract volume label from AM_VOL entry with code comversion */
+					do {
+#if _LFN_UNICODE
+						w = (si < 11) ? dj.dir[si++] : ' ';
+						if (IsDBCS1(w) && si < 11 && IsDBCS2(dj.dir[si])) {
+							w = w << 8 | dj.dir[si++];
+						}
+						label[di++] = ff_convert(w, 1);	/* OEM -> Unicode */
+#else
+						label[di++] = dj.dir[si++];
+#endif
+					} while (di < 11);
+					do {				/* Truncate trailing spaces */
+						label[di] = 0;
+						if (di == 0) break;
+					} while (label[--di] == ' ');
+				}
+			}
+		}
+		if (res == FR_NO_FILE) {	/* No label entry and return nul string */
+			label[0] = 0;
+			res = FR_OK;
+		}
+	}
+
+	/* Get volume serial number */
+	if (res == FR_OK && vsn) {
+		res = move_window(fs, fs->volbase);
+		if (res == FR_OK) {
+			switch (fs->fs_type) {
+			case FS_EXFAT: di = BPB_VolIDEx; break;
+			case FS_FAT32: di = BS_VolID32; break;
+			default:       di = BS_VolID;
+			}
+			*vsn = ld_dword(fs->win + di);
+		}
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Set Volume Label                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_setlabel (
+	const TCHAR* label	/* Pointer to the volume label to set */
+)
+{
+	FRESULT res;
+	DIR dj;
+	FATFS *fs;
+	BYTE dirvn[22];
+	UINT i, j, slen;
+	WCHAR w;
+	static const char badchr[] = "\"*+,.:;<=>\?[]|\x7F";
+
+
+	/* Get logical drive number */
+	res = find_volume(&label, &fs, FA_WRITE);
+	if (res != FR_OK) LEAVE_FF(fs, res);
+	dj.obj.fs = fs;
+
+	/* Get length of given volume label */
+	for (slen = 0; (UINT)label[slen] >= ' '; slen++) ;	/* Get name length */
+
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {	/* At the exFAT */
+		for (i = j = 0; i < slen; ) {	/* Create volume label in directory form */
+			w = label[i++];
+#if !_LFN_UNICODE
+			if (IsDBCS1(w)) {
+				w = (i < slen && IsDBCS2(label[i])) ? w << 8 | (BYTE)label[i++] : 0;
+			}
+			w = ff_convert(w, 1);
+#endif
+			if (w == 0 || chk_chr(badchr, w) || j == 22) {	/* Check validity check validity of the volume label */
+				LEAVE_FF(fs, FR_INVALID_NAME);
+			}
+			st_word(dirvn + j, w); j += 2;
+		}
+		slen = j;
+	} else
+#endif
+	{	/* At the FAT12/16/32 */
+		for ( ; slen && label[slen - 1] == ' '; slen--) ;	/* Remove trailing spaces */
+		if (slen) {		/* Is there a volume label to be set? */
+			dirvn[0] = 0; i = j = 0;	/* Create volume label in directory form */
+			do {
+#if _LFN_UNICODE
+				w = ff_convert(ff_wtoupper(label[i++]), 0);
+#else
+				w = (BYTE)label[i++];
+				if (IsDBCS1(w)) {
+					w = (j < 10 && i < slen && IsDBCS2(label[i])) ? w << 8 | (BYTE)label[i++] : 0;
+				}
+#if _USE_LFN != 0
+				w = ff_convert(ff_wtoupper(ff_convert(w, 1)), 0);
+#else
+				if (IsLower(w)) w -= 0x20;			/* To upper ASCII characters */
+#ifdef _EXCVT
+				if (w >= 0x80) w = ExCvt[w - 0x80];	/* To upper extended characters (SBCS cfg) */
+#else
+				if (!_DF1S && w >= 0x80) w = 0;		/* Reject extended characters (ASCII cfg) */
+#endif
+#endif
+#endif
+				if (w == 0 || chk_chr(badchr, w) || j >= (UINT)((w >= 0x100) ? 10 : 11)) {	/* Reject invalid characters for volume label */
+					LEAVE_FF(fs, FR_INVALID_NAME);
+				}
+				if (w >= 0x100) dirvn[j++] = (BYTE)(w >> 8);
+				dirvn[j++] = (BYTE)w;
+			} while (i < slen);
+			while (j < 11) dirvn[j++] = ' ';	/* Fill remaining name field */
+			if (dirvn[0] == DDEM) LEAVE_FF(fs, FR_INVALID_NAME);	/* Reject illegal name (heading DDEM) */
+		}
+	}
+
+	/* Set volume label */
+	dj.obj.sclust = 0;		/* Open root directory */
+	res = dir_sdi(&dj, 0);
+	if (res == FR_OK) {
+		res = dir_read(&dj, 1);	/* Get volume label entry */
+		if (res == FR_OK) {
+			if (_FS_EXFAT && fs->fs_type == FS_EXFAT) {
+				dj.dir[XDIR_NumLabel] = slen / 2;	/* Change the volume label */
+				mem_cpy(dj.dir + XDIR_Label, dirvn, slen);
+			} else {
+				if (slen) {
+					mem_cpy(dj.dir, dirvn, 11);	/* Change the volume label */
+				} else {
+					dj.dir[DIR_Name] = DDEM;	/* Remove the volume label */
+				}
+			}
+			fs->wflag = 1;
+			res = sync_fs(fs);
+		} else {			/* No volume label entry is found or error */
+			if (res == FR_NO_FILE) {
+				res = FR_OK;
+				if (slen) {	/* Create a volume label entry */
+					res = dir_alloc(&dj, 1);	/* Allocate an entry */
+					if (res == FR_OK) {
+						mem_set(dj.dir, 0, SZDIRE);	/* Clear the entry */
+						if (_FS_EXFAT && fs->fs_type == FS_EXFAT) {
+							dj.dir[XDIR_Type] = 0x83;		/* Create 83 entry */
+							dj.dir[XDIR_NumLabel] = slen / 2;
+							mem_cpy(dj.dir + XDIR_Label, dirvn, slen);
+						} else {
+							dj.dir[DIR_Attr] = AM_VOL;		/* Create volume label entry */
+							mem_cpy(dj.dir, dirvn, 11);
+						}
+						fs->wflag = 1;
+						res = sync_fs(fs);
+					}
+				}
+			}
+		}
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _USE_LABEL */
+
+
+
+#if _USE_EXPAND && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Allocate a Contiguous Blocks to the File                              */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_expand (
+	FIL* fp,		/* Pointer to the file object */
+	FSIZE_t fsz,	/* File size to be expanded to */
+	BYTE opt		/* Operation mode 0:Find and prepare or 1:Find and allocate */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD n, clst, stcl, scl, ncl, tcl, lclst;
+
+
+	res = validate(fp, &fs);		/* Check validity of the object */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+	if (fsz == 0 || fp->obj.objsize != 0 || !(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);
+#if _FS_EXFAT
+	if (fs->fs_type != FS_EXFAT && fsz >= 0x100000000) LEAVE_FF(fs, FR_DENIED);	/* Check if in size limit */
+#endif
+	n = (DWORD)fs->csize * SS(fs);	/* Cluster size */
+	tcl = (DWORD)(fsz / n) + ((fsz & (n - 1)) ? 1 : 0);	/* Number of clusters required */
+	stcl = fs->last_clst; lclst = 0;
+	if (stcl < 2 || stcl >= fs->n_fatent) stcl = 2;
+
+#if _FS_EXFAT
+	if (fs->fs_type == FS_EXFAT) {
+		scl = find_bitmap(fs, stcl, tcl);			/* Find a contiguous cluster block */
+		if (scl == 0) res = FR_DENIED;				/* No contiguous cluster block was found */
+		if (scl == 0xFFFFFFFF) res = FR_DISK_ERR;
+		if (res == FR_OK) {
+			if (opt) {
+				res = change_bitmap(fs, scl, tcl, 1);	/* Mark the cluster block 'in use' */
+				lclst = scl + tcl - 1;
+			} else {
+				lclst = scl - 1;
+			}
+		}
+	} else
+#endif
+	{
+		scl = clst = stcl; ncl = 0;
+		for (;;) {	/* Find a contiguous cluster block */
+			n = get_fat(&fp->obj, clst);
+			if (++clst >= fs->n_fatent) clst = 2;
+			if (n == 1) { res = FR_INT_ERR; break; }
+			if (n == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
+			if (n == 0) {	/* Is it a free cluster? */
+				if (++ncl == tcl) break;	/* Break if a contiguous cluster block is found */
+			} else {
+				scl = clst; ncl = 0;		/* Not a free cluster */
+			}
+			if (clst == stcl) { res = FR_DENIED; break; }	/* No contiguous cluster? */
+		}
+		if (res == FR_OK) {
+			if (opt) {
+				for (clst = scl, n = tcl; n; clst++, n--) {	/* Create a cluster chain on the FAT */
+					res = put_fat(fs, clst, (n == 1) ? 0xFFFFFFFF : clst + 1);
+					if (res != FR_OK) break;
+					lclst = clst;
+				}
+			} else {
+				lclst = scl - 1;
+			}
+		}
+	}
+
+	if (res == FR_OK) {
+		fs->last_clst = lclst;		/* Set suggested start cluster to start next */
+		if (opt) {
+			fp->obj.sclust = scl;		/* Update object allocation information */
+			fp->obj.objsize = fsz;
+			if (_FS_EXFAT) fp->obj.stat = 2;	/* Set status 'contiguous chain' */
+			fp->flag |= FA_MODIFIED;
+			if (fs->free_clst  < fs->n_fatent - 2) {	/* Update FSINFO */
+				fs->free_clst -= tcl;
+				fs->fsi_flag |= 1;
+			}
+		}
+	}
+
+	LEAVE_FF(fs, res);
+}
+
+#endif /* _USE_EXPAND && !_FS_READONLY */
+
+
+
+#if _USE_FORWARD
+/*-----------------------------------------------------------------------*/
+/* Forward data to the stream directly                                   */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_forward (
+	FIL* fp, 						/* Pointer to the file object */
+	UINT (*func)(const BYTE*,UINT),	/* Pointer to the streaming function */
+	UINT btf,						/* Number of bytes to forward */
+	UINT* bf						/* Pointer to number of bytes forwarded */
+)
+{
+	FRESULT res;
+	FATFS *fs;
+	DWORD clst, sect;
+	FSIZE_t remain;
+	UINT rcnt, csect;
+	BYTE *dbuf;
+
+
+	*bf = 0;	/* Clear transfer byte counter */
+	res = validate(fp, &fs);		/* Check validity of the object */
+	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);	/* Check validity */
+	if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_DENIED);	/* Check access mode */
+
+	remain = fp->obj.objsize - fp->fptr;
+	if (btf > remain) btf = (UINT)remain;			/* Truncate btf by remaining bytes */
+
+	for ( ;  btf && (*func)(0, 0);					/* Repeat until all data transferred or stream goes busy */
+		fp->fptr += rcnt, *bf += rcnt, btf -= rcnt) {
+		csect = (UINT)(fp->fptr / SS(fs) & (fs->csize - 1));	/* Sector offset in the cluster */
+		if (fp->fptr % SS(fs) == 0) {				/* On the sector boundary? */
+			if (csect == 0) {						/* On the cluster boundary? */
+				clst = (fp->fptr == 0) ?			/* On the top of the file? */
+					fp->obj.sclust : get_fat(&fp->obj, fp->clust);
+				if (clst <= 1) ABORT(fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
+				fp->clust = clst;					/* Update current cluster */
+			}
+		}
+		sect = clust2sect(fs, fp->clust);			/* Get current data sector */
+		if (!sect) ABORT(fs, FR_INT_ERR);
+		sect += csect;
+#if _FS_TINY
+		if (move_window(fs, sect) != FR_OK) ABORT(fs, FR_DISK_ERR);	/* Move sector window to the file data */
+		dbuf = fs->win;
+#else
+		if (fp->sect != sect) {		/* Fill sector cache with file data */
+#if !_FS_READONLY
+			if (fp->flag & FA_DIRTY) {		/* Write-back dirty sector cache */
+				if (disk_write(fs->drv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+				fp->flag &= ~FA_DIRTY;
+			}
+#endif
+			if (disk_read(fs->drv, fp->buf, sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
+		}
+		dbuf = fp->buf;
+#endif
+		fp->sect = sect;
+		rcnt = SS(fs) - (UINT)fp->fptr % SS(fs);	/* Number of bytes left in the sector */
+		if (rcnt > btf) rcnt = btf;					/* Clip it by btr if needed */
+		rcnt = (*func)(dbuf + ((UINT)fp->fptr % SS(fs)), rcnt);	/* Forward the file data */
+		if (!rcnt) ABORT(fs, FR_INT_ERR);
+	}
+
+	LEAVE_FF(fs, FR_OK);
+}
+#endif /* _USE_FORWARD */
+
+
+
+#if _USE_MKFS && !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Create FAT file system on the logical drive                           */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_mkfs (
+	const TCHAR* path,	/* Logical drive number */
+	BYTE opt,			/* Format option */
+	DWORD au,			/* Size of allocation unit [byte] */
+	void* work,			/* Pointer to working buffer */
+	UINT len			/* Size of working buffer */
+)
+{
+	const UINT n_fats = 1;		/* Number of FATs for FAT12/16/32 volume (1 or 2) */
+	const UINT n_rootdir = 512;	/* Number of root directory entries for FAT12/16 volume */
+	static const WORD cst[] = {1, 4, 16, 64, 256, 512, 0};	/* Cluster size boundary for FAT12/16 volume (4KS unit) */
+	static const WORD cst32[] = {1, 2, 4, 8, 16, 32, 0};	/* Cluster size boundary for FAT32 volume (128KS unit) */
+	BYTE fmt, sys, *buf, *pte, pdrv, part;
+	WORD ss;
+	DWORD n, pau, n_clst, sz_blk, sect, szb_buf, sz_buf;
+	DWORD b_vol, b_fat, b_data;				/* Base LBA for volume, fat, data */
+	DWORD sz_vol, sz_rsv, sz_fat, sz_dir;	/* Size for volume, fat, dir, data */
+	UINT i, ns;
+	int vol;
+	DSTATUS stat;
+#if _USE_TRIM || _FS_EXFAT
+	DWORD tbl[3];
+#endif
+
+
+	/* Check mounted drive and clear work area */
+	vol = get_ldnumber(&path);					/* Get target logical drive */
+	if (vol < 0) return FR_INVALID_DRIVE;
+	if (FatFs[vol]) FatFs[vol]->fs_type = 0;	/* Clear mounted volume */
+	pdrv = LD2PD(vol);	/* Physical drive */
+	part = LD2PT(vol);	/* Partition (0:create as new, 1-4:get by partition table) */
+
+	/* Check physical drive status */
+	stat = disk_initialize(pdrv);
+	if (stat & STA_NOINIT) return FR_NOT_READY;
+	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
+	if (disk_ioctl(pdrv, GET_BLOCK_SIZE, &sz_blk) != RES_OK || !sz_blk || sz_blk > 32768 || (sz_blk & (sz_blk - 1))) sz_blk = 1;
+#if _MAX_SS != _MIN_SS		/* Get sector size of the medium */
+	if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &ss) != RES_OK) return FR_DISK_ERR;
+	if (ss > _MAX_SS || ss < _MIN_SS || (ss & (ss - 1))) return FR_DISK_ERR;
+#else
+	ss = _MAX_SS;
+#endif
+	if ((au != 0 && au < ss) || (au & (au - 1))) return FR_INVALID_PARAMETER;	/* Check if au is valid */
+	au /= ss;	/* Cluster size in byte to in sector */
+	if (au > 32768) return FR_INVALID_PARAMETER;
+
+	/* Set size and pointer of the working buffer */
+	buf = (BYTE*)work;			/* Use given working buffer */
+	if (len < ss) return FR_MKFS_ABORTED;
+	szb_buf = len & ~(ss - 1);	/* Round-down by sector size [byte] */
+	sz_buf = szb_buf / ss;		/* Size of sector buffer [sector] */
+
+	/* Determine where the volume to be located (b_vol, sz_vol) */
+	if (_MULTI_PARTITION && part != 0) {
+		/* Get partition information from partition table in the MBR */
+		if (disk_read(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;	/* Load MBR */
+		if (ld_word(buf + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;	/* Check MBR is valid */
+		pte = buf + (MBR_Table + (part - 1) * SZ_PTE);
+		if (!pte[PTE_System]) return FR_MKFS_ABORTED;	/* No partition? */
+		b_vol = ld_dword(pte + PTE_StLba);		/* Get volume start sector */
+		sz_vol = ld_dword(pte + PTE_SizLba);	/* Get volume size */
+	} else {
+		/* Create a single-partition in this function */
+		if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_vol) != RES_OK) return FR_DISK_ERR;
+		b_vol = (opt & FM_SFD) ? 0 : 63;		/* Volume start sector */
+		if (sz_vol < b_vol) return FR_MKFS_ABORTED;
+		sz_vol -= b_vol;						/* Volume size */
+	}
+	if (sz_vol < 128) return FR_MKFS_ABORTED;	/* Check volume size (>=128s) */
+
+	/* Pre-determine the FAT type by argument */
+	do {
+		if (_FS_EXFAT && (opt & FM_EXFAT)) {	/* exFAT possible? */
+			if ((opt & FM_ANY) == FM_EXFAT || sz_vol >= 0x4000000 || au >= 256) {	/* exFAT only, vol >= 64Ms or au >= 256s ? */
+				fmt = FS_EXFAT; break;
+			}
+		}
+		if (au >= 256) return FR_INVALID_PARAMETER;	/* Too large au for FAT/FAT32 */
+		if (opt & FM_FAT32) {	/* FAT32 possible? */
+			if ((opt & FM_ANY) == FM_FAT32 || !(opt & FM_FAT)) {	/* FAT32 only or no-FAT? */
+				fmt = FS_FAT32; break;
+			}
+		}
+		if (!(opt & FM_FAT)) return FR_INVALID_PARAMETER;	/* no-FAT? */
+		fmt = FS_FAT16;
+	} while (0);
+
+#if _FS_EXFAT
+	if (fmt == FS_EXFAT) {	/* Create an exFAT volume */
+		DWORD szb_bit, szb_case, sum, nb, cl;
+		WCHAR ch, si;
+		UINT j, st;
+		BYTE b;
+
+		if (sz_vol < 0x1000) return FR_MKFS_ABORTED;	/* Too small volume? */
+#if _USE_TRIM
+		tbl[0] = b_vol; tbl[1] = b_vol + sz_vol - 1;	/* Inform the device the volume area can be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, tbl);
+#endif
+		/* Determine FAT location, data location and number of clusters */
+		if (!au) {	/* au auto-selection */
+			au = 8;
+			if (sz_vol >= 0x80000) au = 64;		/* >= 512KS */
+			if (sz_vol >= 0x4000000) au = 256;	/* >= 64MS */
+		}
+		b_fat = b_vol + 32;										/* FAT start at offset 32 */
+		sz_fat = ((sz_vol / au + 2) * 4 + ss - 1) / ss;			/* Numbef of FAT sectors */
+		b_data = (b_fat + sz_fat + sz_blk - 1) & ~(sz_blk - 1);	/* Align data area to the erase block boundary */
+		if (b_data >= sz_vol / 2) return FR_MKFS_ABORTED;		/* Too small volume? */
+		n_clst = (sz_vol - (b_data - b_vol)) / au;				/* Nunber of clusters */
+		if (n_clst <16) return FR_MKFS_ABORTED;					/* Too few clusters? */
+		if (n_clst > MAX_EXFAT) return FR_MKFS_ABORTED;			/* Too many clusters? */
+
+		szb_bit = (n_clst + 7) / 8;		/* Size of allocation bitmap */
+		tbl[0] = (szb_bit + au * ss - 1) / (au * ss);	/* Number of bitmap clusters */
+		tbl[2] = 1;										/* Number of rootdir clusters */
+
+		/* Create a compressed up-case table */
+		sect = b_data + au * tbl[0];	/* Table start sector */
+		sum = 0;						/* Table checksum to be stored in the 82 entry */
+		st = si = i = j = szb_case = 0;
+		do {
+			switch (st) {
+			case 0:
+				ch = ff_wtoupper(si);	/* Get an up-case char */
+				if (ch != si) {
+					si++; break;		/* Store the up-case char if exist */
+				}
+				for (j = 1; (WCHAR)(si + j) && (WCHAR)(si + j) == ff_wtoupper((WCHAR)(si + j)); j++) ;	/* Get run length of no-case block */
+				if (j >= 128) {
+					ch = 0xFFFF; st = 2; break;	/* Compress the no-case block if run is >= 128 */
+				}
+				st = 1;			/* Do not compress short run */
+				/* continue */
+			case 1:
+				ch = si++;		/* Fill the short run */
+				if (--j == 0) st = 0;
+				break;
+			default:
+				ch = (WCHAR)j; si += j;	/* Number of chars to skip */
+				st = 0;
+			}
+			sum = xsum32(buf[i + 0] = (BYTE)ch, sum);		/* Put it into the write buffer */
+			sum = xsum32(buf[i + 1] = (BYTE)(ch >> 8), sum);
+			i += 2; szb_case += 2;
+			if (!si || i == szb_buf) {		/* Write buffered data when buffer full or end of process */
+				ns = (i + ss - 1) / ss;
+				if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+				sect += ns; i = 0;
+			}
+		} while (si);
+		tbl[1] = (szb_case + au * ss - 1) / (au * ss);	/* Number of up-case clusters */
+
+		/* Initialize the allocation bitmap */
+		sect = b_data; n = (szb_bit + ss - 1) / ss;		/* Start of bitmap and number of the sectors */
+		nb = tbl[0] + tbl[1] + tbl[2];					/* Number of clusters in-use by system */
+		do {
+			mem_set(buf, 0, szb_buf);
+			for (i = 0; nb >= 8 && i < szb_buf; buf[i++] = 0xFF, nb -= 8) ;
+			for (b = 1; nb && i < szb_buf; buf[i] |= b, b <<= 1, nb--) ;
+			ns = (n > sz_buf) ? sz_buf : n;				/* Write the buffered data */
+			if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+			sect += ns; n -= ns;
+		} while (n);
+
+		/* Initialize the FAT */
+		sect = b_fat; n = sz_fat;	/* Start of FAT and number of the sectors */
+		j = nb = cl = 0;
+		do {
+			mem_set(buf, 0, szb_buf); i = 0;
+			if (cl == 0) {	/* Set entry 0 and 1 */
+				st_dword(buf + i, 0xFFFFFFF8); i += 4; cl++;
+				st_dword(buf + i, 0xFFFFFFFF); i += 4; cl++;
+			}
+			do {			/* Create chains of bitmap, up-case and root dir */
+				while (nb && i < szb_buf) {			/* Create a chain */
+					st_dword(buf + i, (nb > 1) ? cl + 1 : 0xFFFFFFFF);
+					i += 4; cl++; nb--;
+				}
+				if (!nb && j < 3) nb = tbl[j++];	/* Next chain */
+			} while (nb && i < szb_buf);
+			ns = (n > sz_buf) ? sz_buf : n;			/* Write the buffered data */
+			if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+			sect += ns; n -= ns;
+		} while (n);
+
+		/* Initialize the root directory */
+		mem_set(buf, 0, ss);
+		buf[SZDIRE * 0 + 0] = 0x83;		/* 83 entry (volume label) */
+		buf[SZDIRE * 1 + 0] = 0x81;		/* 81 entry (allocation bitmap) */
+		st_dword(buf + SZDIRE * 1 + 20, 2);
+		st_dword(buf + SZDIRE * 1 + 24, szb_bit);
+		buf[SZDIRE * 2 + 0] = 0x82;		/* 82 entry (up-case table) */
+		st_dword(buf + SZDIRE * 2 + 4, sum);
+		st_dword(buf + SZDIRE * 2 + 20, 2 + tbl[0]);
+		st_dword(buf + SZDIRE * 2 + 24, szb_case);
+		sect = b_data + au * (tbl[0] + tbl[1]);	n = au;	/* Start of directory and number of the sectors */
+		do {	/* Fill root direcotry sectors */
+			ns = (n > sz_buf) ? sz_buf : n;
+			if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+			sect += ns;
+			mem_set(buf, 0, ss);
+		} while (n -= ns);
+
+		/* Create two set of the exFAT VBR blocks */
+		sect = b_vol;
+		for (n = 0; n < 2; n++) {
+			/* Main record (+0) */
+			mem_set(buf, 0, ss);
+			mem_cpy(buf + BS_JmpBoot, "\xEB\x76\x90" "EXFAT   ", 11);	/* Boot jump code (x86), OEM name */
+			st_dword(buf + BPB_VolOfsEx, b_vol);					/* Volume offset in the physical drive [sector] */
+			st_dword(buf + BPB_TotSecEx, sz_vol);					/* Volume size [sector] */
+			st_dword(buf + BPB_FatOfsEx, b_fat - b_vol);			/* FAT offset [sector] */
+			st_dword(buf + BPB_FatSzEx, sz_fat);					/* FAT size [sector] */
+			st_dword(buf + BPB_DataOfsEx, b_data - b_vol);			/* Data offset [sector] */
+			st_dword(buf + BPB_NumClusEx, n_clst);					/* Number of clusters */
+			st_dword(buf + BPB_RootClusEx, 2 + tbl[0] + tbl[1]);	/* Root dir cluster # */
+			st_dword(buf + BPB_VolIDEx, GET_FATTIME());				/* VSN */
+			st_word(buf + BPB_FSVerEx, 0x100);						/* File system version (1.00) */
+			for (buf[BPB_BytsPerSecEx] = 0, i = ss; i >>= 1; buf[BPB_BytsPerSecEx]++) ;	/* Log2 of sector size [byte] */
+			for (buf[BPB_SecPerClusEx] = 0, i = au; i >>= 1; buf[BPB_SecPerClusEx]++) ;	/* Log2 of cluster size [sector] */
+			buf[BPB_NumFATsEx] = 1;					/* Number of FATs */
+			buf[BPB_DrvNumEx] = 0x80;				/* Drive number (for int13) */
+			st_word(buf + BS_BootCodeEx, 0xFEEB);	/* Boot code (x86) */
+			st_word(buf + BS_55AA, 0xAA55);			/* Signature (placed here regardless of sector size) */
+			for (i = sum = 0; i < ss; i++) {		/* VBR checksum */
+				if (i != BPB_VolFlagEx && i != BPB_VolFlagEx + 1 && i != BPB_PercInUseEx) sum = xsum32(buf[i], sum);
+			}
+			if (disk_write(pdrv, buf, sect++, 1) != RES_OK) return FR_DISK_ERR;
+			/* Extended bootstrap record (+1..+8) */
+			mem_set(buf, 0, ss);
+			st_word(buf + ss - 2, 0xAA55);	/* Signature (placed at end of sector) */
+			for (j = 1; j < 9; j++) {
+				for (i = 0; i < ss; sum = xsum32(buf[i++], sum)) ;	/* VBR checksum */
+				if (disk_write(pdrv, buf, sect++, 1) != RES_OK) return FR_DISK_ERR;
+			}
+			/* OEM/Reserved record (+9..+10) */
+			mem_set(buf, 0, ss);
+			for ( ; j < 11; j++) {
+				for (i = 0; i < ss; sum = xsum32(buf[i++], sum)) ;	/* VBR checksum */
+				if (disk_write(pdrv, buf, sect++, 1) != RES_OK) return FR_DISK_ERR;
+			}
+			/* Sum record (+11) */
+			for (i = 0; i < ss; i += 4) st_dword(buf + i, sum);		/* Fill with checksum value */
+			if (disk_write(pdrv, buf, sect++, 1) != RES_OK) return FR_DISK_ERR;
+		}
+
+	} else
+#endif
+	{	/* Create an FAT12/16/32 volume */
+		do {
+			pau = au;
+			/* Pre-determine number of clusters and FAT sub-type */
+			if (fmt == FS_FAT32) {	/* FAT32 volume */
+				if (!pau) {	/* au auto-selection */
+					n = sz_vol / 0x20000;	/* Volume size in unit of 128KS */
+					for (i = 0, pau = 1; cst32[i] && cst32[i] <= n; i++, pau <<= 1) ;	/* Get from table */
+				}
+				n_clst = sz_vol / pau;	/* Number of clusters */
+				sz_fat = (n_clst * 4 + 8 + ss - 1) / ss;	/* FAT size [sector] */
+				sz_rsv = 32;	/* Number of reserved sectors */
+				sz_dir = 0;		/* No static directory */
+				if (n_clst <= MAX_FAT16 || n_clst > MAX_FAT32) return FR_MKFS_ABORTED;
+			} else {				/* FAT12/16 volume */
+				if (!pau) {	/* au auto-selection */
+					n = sz_vol / 0x1000;	/* Volume size in unit of 4KS */
+					for (i = 0, pau = 1; cst[i] && cst[i] <= n; i++, pau <<= 1) ;	/* Get from table */
+				}
+				n_clst = sz_vol / pau;
+				if (n_clst > MAX_FAT12) {
+					n = n_clst * 2 + 4;		/* FAT size [byte] */
+				} else {
+					fmt = FS_FAT12;
+					n = (n_clst * 3 + 1) / 2 + 3;	/* FAT size [byte] */
+				}
+				sz_fat = (n + ss - 1) / ss;		/* FAT size [sector] */
+				sz_rsv = 1;						/* Number of reserved sectors */
+				sz_dir = (DWORD)n_rootdir * SZDIRE / ss;	/* Rootdir size [sector] */
+			}
+			b_fat = b_vol + sz_rsv;						/* FAT base */
+			b_data = b_fat + sz_fat * n_fats + sz_dir;	/* Data base */
+
+			/* Align data base to erase block boundary (for flash memory media) */
+			n = ((b_data + sz_blk - 1) & ~(sz_blk - 1)) - b_data;	/* Next nearest erase block from current data base */
+			if (fmt == FS_FAT32) {		/* FAT32: Move FAT base */
+				sz_rsv += n; b_fat += n;
+			} else {					/* FAT12/16: Expand FAT size */
+				sz_fat += n / n_fats;
+			}
+
+			/* Determine number of clusters and final check of validity of the FAT sub-type */
+			if (sz_vol < b_data + pau * 16 - b_vol) return FR_MKFS_ABORTED;	/* Too small volume */
+			n_clst = (sz_vol - sz_rsv - sz_fat * n_fats - sz_dir) / pau;
+			if (fmt == FS_FAT32) {
+				if (n_clst <= MAX_FAT16) {	/* Too few clusters for FAT32 */
+					if (!au && (au = pau / 2) != 0) continue;	/* Adjust cluster size and retry */
+					return FR_MKFS_ABORTED;
+				}
+			}
+			if (fmt == FS_FAT16) {
+				if (n_clst > MAX_FAT16) {	/* Too many clusters for FAT16 */
+					if (!au && (pau * 2) <= 64) {
+						au = pau * 2; continue;		/* Adjust cluster size and retry */
+					}
+					if ((opt & FM_FAT32)) {
+						fmt = FS_FAT32; continue;	/* Switch type to FAT32 and retry */
+					}
+					if (!au && (au = pau * 2) <= 128) continue;	/* Adjust cluster size and retry */
+					return FR_MKFS_ABORTED;
+				}
+				if  (n_clst <= MAX_FAT12) {	/* Too few clusters for FAT16 */
+					if (!au && (au = pau * 2) <= 128) continue;	/* Adjust cluster size and retry */
+					return FR_MKFS_ABORTED;
+				}
+			}
+			if (fmt == FS_FAT12 && n_clst > MAX_FAT12) return FR_MKFS_ABORTED;	/* Too many clusters for FAT12 */
+
+			/* Ok, it is the valid cluster configuration */
+			break;
+		} while (1);
+
+#if _USE_TRIM
+		tbl[0] = b_vol; tbl[1] = b_vol + sz_vol - 1;	/* Inform the device the volume area can be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, tbl);
+#endif
+		/* Create FAT VBR */
+		mem_set(buf, 0, ss);
+		mem_cpy(buf + BS_JmpBoot, "\xEB\xFE\x90" "MSDOS5.0", 11);/* Boot jump code (x86), OEM name */
+		st_word(buf + BPB_BytsPerSec, ss);				/* Sector size [byte] */
+		buf[BPB_SecPerClus] = (BYTE)pau;				/* Cluster size [sector] */
+		st_word(buf + BPB_RsvdSecCnt, (WORD)sz_rsv);	/* Size of reserved area */
+		buf[BPB_NumFATs] = n_fats;						/* Number of FATs */
+		st_word(buf + BPB_RootEntCnt, (WORD)((fmt == FS_FAT32) ? 0 : n_rootdir));	/* Number of root directory entries */
+		if (sz_vol < 0x10000) {
+			st_word(buf + BPB_TotSec16, (WORD)sz_vol);	/* Volume size in 16-bit LBA */
+		} else {
+			st_dword(buf + BPB_TotSec32, sz_vol);		/* Volume size in 12-bit LBA */
+		}
+		buf[BPB_Media] = 0xF8;							/* Media descriptor */
+		st_word(buf + BPB_SecPerTrk, 63);				/* Number of sectors per track (for int13) */
+		st_word(buf + BPB_NumHeads, 255);				/* Number of heads (for int13) */
+		st_dword(buf + BPB_HiddSec, b_vol);				/* Volume offset in the physical drive [sector] */
+		if (fmt == FS_FAT32) {
+			st_dword(buf + BS_VolID32, GET_FATTIME());	/* VSN */
+			st_dword(buf + BPB_FATSz32, sz_fat);		/* FAT size [sector] */
+			st_dword(buf + BPB_RootClus32, 2);			/* Root directory cluster # (2) */
+			st_word(buf + BPB_FSInfo32, 1);				/* Offset of FSINFO sector (VBR + 1) */
+			st_word(buf + BPB_BkBootSec32, 6);			/* Offset of backup VBR (VBR + 6) */
+			buf[BS_DrvNum32] = 0x80;					/* Drive number (for int13) */
+			buf[BS_BootSig32] = 0x29;					/* Extended boot signature */
+			mem_cpy(buf + BS_VolLab32, "NO NAME    " "FAT32   ", 19);	/* Volume label, FAT signature */
+		} else {
+			st_dword(buf + BS_VolID, GET_FATTIME());	/* VSN */
+			st_word(buf + BPB_FATSz16, (WORD)sz_fat);	/* FAT size [sector] */
+			buf[BS_DrvNum] = 0x80;						/* Drive number (for int13) */
+			buf[BS_BootSig] = 0x29;						/* Extended boot signature */
+			mem_cpy(buf + BS_VolLab, "NO NAME    " "FAT     ", 19);	/* Volume label, FAT signature */
+		}
+		st_word(buf + BS_55AA, 0xAA55);					/* Signature (offset is fixed here regardless of sector size) */
+		if (disk_write(pdrv, buf, b_vol, 1) != RES_OK) return FR_DISK_ERR;	/* Write it to the VBR sector */
+
+		/* Create FSINFO record if needed */
+		if (fmt == FS_FAT32) {
+			disk_write(pdrv, buf, b_vol + 6, 1);		/* Write backup VBR (VBR + 6) */
+			mem_set(buf, 0, ss);
+			st_dword(buf + FSI_LeadSig, 0x41615252);
+			st_dword(buf + FSI_StrucSig, 0x61417272);
+			st_dword(buf + FSI_Free_Count, n_clst - 1);	/* Number of free clusters */
+			st_dword(buf + FSI_Nxt_Free, 2);			/* Last allocated cluster# */
+			st_word(buf + BS_55AA, 0xAA55);
+			disk_write(pdrv, buf, b_vol + 7, 1);		/* Write backup FSINFO (VBR + 7) */
+			disk_write(pdrv, buf, b_vol + 1, 1);		/* Write original FSINFO (VBR + 1) */
+		}
+
+		/* Initialize FAT area */
+		mem_set(buf, 0, szb_buf);
+		sect = b_fat;		/* Start sector */
+		for (i = 0; i < n_fats; i++) {			/* Initialize FATs each */
+			if (fmt == FS_FAT32) {
+				st_dword(buf + 0, 0xFFFFFFF8);	/* Entry 0 */
+				st_dword(buf + 4, 0xFFFFFFFF);	/* Entry 1 */
+				st_dword(buf + 8, 0x0FFFFFFF);	/* Entry 2 (root directory) */
+			} else {
+				st_dword(buf + 0, (fmt == FS_FAT12) ? 0xFFFFF8 : 0xFFFFFFF8);	/* Entry 0 and 1 */
+			}
+			n = sz_fat;		/* Sector count of a FAT */
+			do {	/* Fill FAT sectors */
+				ns = (n > sz_buf) ? sz_buf : n;
+				if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+				sect += ns;
+				mem_set(buf, 0, ss);
+			} while (n -= ns);
+		}
+
+		/* Initialize root directory (fill with zero) */
+		n = (fmt == FS_FAT32) ? pau : sz_dir;		/* Sector count of root directory */
+		do {
+			ns = (n > sz_buf) ? sz_buf : n;
+			if (disk_write(pdrv, buf, sect, ns) != RES_OK) return FR_DISK_ERR;
+			sect += ns;
+		} while (n -= ns);
+	}
+
+	/* Determine system ID in the partition table */
+	if (_FS_EXFAT && fmt == FS_EXFAT) {
+		sys = 0x07;			/* HPFS/NTFS/exFAT */
+	} else {
+		if (fmt == FS_FAT32) {
+			sys = 0x0C;		/* FAT32X */
+		} else {
+			if (sz_vol >= 0x10000) {
+				sys = 0x06;	/* FAT12/16 (>=64KS) */
+			} else {
+				sys = (fmt == FS_FAT16) ? 0x04 : 0x01;	/* FAT16 (<64KS) : FAT12 (<64KS) */
+			}
+		}
+	}
+
+	if (_MULTI_PARTITION && part != 0) {
+		/* Update system ID in the partition table */
+		if (disk_read(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;	/* Read the MBR */
+		buf[MBR_Table + (part - 1) * SZ_PTE + PTE_System] = sys;		/* Set system type */
+		if (disk_write(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;	/* Write it back to the MBR */
+	} else {
+		if (!(opt & FM_SFD)) {
+			/* Create partition table in FDISK format */
+			mem_set(buf, 0, ss);
+			st_word(buf + BS_55AA, 0xAA55);		/* MBR signature */
+			pte = buf + MBR_Table;				/* Create partition table for single partition in the drive */
+			pte[PTE_Boot] = 0;					/* Boot indicator */
+			pte[PTE_StHead] = 1;				/* Start head */
+			pte[PTE_StSec] = 1;					/* Start sector */
+			pte[PTE_StCyl] = 0;					/* Start cylinder */
+			pte[PTE_System] = sys;				/* System type */
+			n = (b_vol + sz_vol) / (63 * 255);	/* (End CHS is incorrect) */
+			pte[PTE_EdHead] = 254;				/* End head */
+			pte[PTE_EdSec] = (BYTE)(n >> 2 | 63);	/* End sector */
+			pte[PTE_EdCyl] = (BYTE)n;			/* End cylinder */
+			st_dword(pte + PTE_StLba, b_vol);	/* Start offset in LBA */
+			st_dword(pte + PTE_SizLba, sz_vol);	/* Size in sectors */
+			if (disk_write(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;	/* Write it to the MBR */
+		}
+	}
+
+	if (disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) return FR_DISK_ERR;
+
+	return FR_OK;
+}
+
+
+
+#if _MULTI_PARTITION
+/*-----------------------------------------------------------------------*/
+/* Create partition table on the physical drive                          */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_fdisk (
+	BYTE pdrv,			/* Physical drive number */
+	const DWORD* szt,	/* Pointer to the size table for each partitions */
+	void* work			/* Pointer to the working buffer */
+)
+{
+	UINT i, n, sz_cyl, tot_cyl, b_cyl, e_cyl, p_cyl;
+	BYTE s_hd, e_hd, *p, *buf = (BYTE*)work;
+	DSTATUS stat;
+	DWORD sz_disk, sz_part, s_part;
+
+
+	stat = disk_initialize(pdrv);
+	if (stat & STA_NOINIT) return FR_NOT_READY;
+	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
+	if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_disk)) return FR_DISK_ERR;
+
+	/* Determine the CHS without any care of the drive geometry */
+	for (n = 16; n < 256 && sz_disk / n / 63 > 1024; n *= 2) ;
+	if (n == 256) n--;
+	e_hd = n - 1;
+	sz_cyl = 63 * n;
+	tot_cyl = sz_disk / sz_cyl;
+
+	/* Create partition table */
+	mem_set(buf, 0, _MAX_SS);
+	p = buf + MBR_Table; b_cyl = 0;
+	for (i = 0; i < 4; i++, p += SZ_PTE) {
+		p_cyl = (szt[i] <= 100U) ? (DWORD)tot_cyl * szt[i] / 100 : szt[i] / sz_cyl;
+		if (!p_cyl) continue;
+		s_part = (DWORD)sz_cyl * b_cyl;
+		sz_part = (DWORD)sz_cyl * p_cyl;
+		if (i == 0) {	/* Exclude first track of cylinder 0 */
+			s_hd = 1;
+			s_part += 63; sz_part -= 63;
+		} else {
+			s_hd = 0;
+		}
+		e_cyl = b_cyl + p_cyl - 1;
+		if (e_cyl >= tot_cyl) return FR_INVALID_PARAMETER;
+
+		/* Set partition table */
+		p[1] = s_hd;						/* Start head */
+		p[2] = (BYTE)((b_cyl >> 2) + 1);	/* Start sector */
+		p[3] = (BYTE)b_cyl;					/* Start cylinder */
+		p[4] = 0x06;						/* System type (temporary setting) */
+		p[5] = e_hd;						/* End head */
+		p[6] = (BYTE)((e_cyl >> 2) + 63);	/* End sector */
+		p[7] = (BYTE)e_cyl;					/* End cylinder */
+		st_dword(p + 8, s_part);			/* Start sector in LBA */
+		st_dword(p + 12, sz_part);			/* Partition size */
+
+		/* Next partition */
+		b_cyl += p_cyl;
+	}
+	st_word(p, 0xAA55);
+
+	/* Write it to the MBR */
+	return (disk_write(pdrv, buf, 0, 1) != RES_OK || disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) ? FR_DISK_ERR : FR_OK;
+}
+
+#endif /* _MULTI_PARTITION */
+#endif /* _USE_MKFS && !_FS_READONLY */
+
+
+
+
+#if _USE_STRFUNC
+/*-----------------------------------------------------------------------*/
+/* Get a string from the file                                            */
+/*-----------------------------------------------------------------------*/
+
+TCHAR* f_gets (
+	TCHAR* buff,	/* Pointer to the string buffer to read */
+	int len,		/* Size of string buffer (characters) */
+	FIL* fp			/* Pointer to the file object */
+)
+{
+	int n = 0;
+	TCHAR c, *p = buff;
+	BYTE s[2];
+	UINT rc;
+
+
+	while (n < len - 1) {	/* Read characters until buffer gets filled */
+#if _LFN_UNICODE
+#if _STRF_ENCODE == 3		/* Read a character in UTF-8 */
+		f_read(fp, s, 1, &rc);
+		if (rc != 1) break;
+		c = s[0];
+		if (c >= 0x80) {
+			if (c < 0xC0) continue;	/* Skip stray trailer */
+			if (c < 0xE0) {			/* Two-byte sequence */
+				f_read(fp, s, 1, &rc);
+				if (rc != 1) break;
+				c = (c & 0x1F) << 6 | (s[0] & 0x3F);
+				if (c < 0x80) c = '?';
+			} else {
+				if (c < 0xF0) {		/* Three-byte sequence */
+					f_read(fp, s, 2, &rc);
+					if (rc != 2) break;
+					c = c << 12 | (s[0] & 0x3F) << 6 | (s[1] & 0x3F);
+					if (c < 0x800) c = '?';
+				} else {			/* Reject four-byte sequence */
+					c = '?';
+				}
+			}
+		}
+#elif _STRF_ENCODE == 2		/* Read a character in UTF-16BE */
+		f_read(fp, s, 2, &rc);
+		if (rc != 2) break;
+		c = s[1] + (s[0] << 8);
+#elif _STRF_ENCODE == 1		/* Read a character in UTF-16LE */
+		f_read(fp, s, 2, &rc);
+		if (rc != 2) break;
+		c = s[0] + (s[1] << 8);
+#else						/* Read a character in ANSI/OEM */
+		f_read(fp, s, 1, &rc);
+		if (rc != 1) break;
+		c = s[0];
+		if (IsDBCS1(c)) {
+			f_read(fp, s, 1, &rc);
+			if (rc != 1) break;
+			c = (c << 8) + s[0];
+		}
+		c = ff_convert(c, 1);	/* OEM -> Unicode */
+		if (!c) c = '?';
+#endif
+#else						/* Read a character without conversion */
+		f_read(fp, s, 1, &rc);
+		if (rc != 1) break;
+		c = s[0];
+#endif
+		if (_USE_STRFUNC == 2 && c == '\r') continue;	/* Strip '\r' */
+		*p++ = c;
+		n++;
+		if (c == '\n') break;		/* Break on EOL */
+	}
+	*p = 0;
+	return n ? buff : 0;			/* When no data read (eof or error), return with error. */
+}
+
+
+
+
+#if !_FS_READONLY
+#include <stdarg.h>
+/*-----------------------------------------------------------------------*/
+/* Put a character to the file                                           */
+/*-----------------------------------------------------------------------*/
+
+typedef struct {
+	FIL *fp;		/* Ptr to the writing file */
+	int idx, nchr;	/* Write index of buf[] (-1:error), number of chars written */
+	BYTE buf[64];	/* Write buffer */
+} putbuff;
+
+
+static
+void putc_bfd (		/* Buffered write with code conversion */
+	putbuff* pb,
+	TCHAR c
+)
+{
+	UINT bw;
+	int i;
+
+
+	if (_USE_STRFUNC == 2 && c == '\n') {	 /* LF -> CRLF conversion */
+		putc_bfd(pb, '\r');
+	}
+
+	i = pb->idx;		/* Write index of pb->buf[] */
+	if (i < 0) return;
+
+#if _LFN_UNICODE
+#if _STRF_ENCODE == 3			/* Write a character in UTF-8 */
+	if (c < 0x80) {				/* 7-bit */
+		pb->buf[i++] = (BYTE)c;
+	} else {
+		if (c < 0x800) {		/* 11-bit */
+			pb->buf[i++] = (BYTE)(0xC0 | c >> 6);
+		} else {				/* 16-bit */
+			pb->buf[i++] = (BYTE)(0xE0 | c >> 12);
+			pb->buf[i++] = (BYTE)(0x80 | (c >> 6 & 0x3F));
+		}
+		pb->buf[i++] = (BYTE)(0x80 | (c & 0x3F));
+	}
+#elif _STRF_ENCODE == 2			/* Write a character in UTF-16BE */
+	pb->buf[i++] = (BYTE)(c >> 8);
+	pb->buf[i++] = (BYTE)c;
+#elif _STRF_ENCODE == 1			/* Write a character in UTF-16LE */
+	pb->buf[i++] = (BYTE)c;
+	pb->buf[i++] = (BYTE)(c >> 8);
+#else							/* Write a character in ANSI/OEM */
+	c = ff_convert(c, 0);	/* Unicode -> OEM */
+	if (!c) c = '?';
+	if (c >= 0x100)
+		pb->buf[i++] = (BYTE)(c >> 8);
+	pb->buf[i++] = (BYTE)c;
+#endif
+#else							/* Write a character without conversion */
+	pb->buf[i++] = (BYTE)c;
+#endif
+
+	if (i >= (int)(sizeof pb->buf) - 3) {	/* Write buffered characters to the file */
+		f_write(pb->fp, pb->buf, (UINT)i, &bw);
+		i = (bw == (UINT)i) ? 0 : -1;
+	}
+	pb->idx = i;
+	pb->nchr++;
+}
+
+
+static
+int putc_flush (		/* Flush left characters in the buffer */
+	putbuff* pb
+)
+{
+	UINT nw;
+
+	if (   pb->idx >= 0	/* Flush buffered characters to the file */
+		&& f_write(pb->fp, pb->buf, (UINT)pb->idx, &nw) == FR_OK
+		&& (UINT)pb->idx == nw) return pb->nchr;
+	return EOF;
+}
+
+
+static
+void putc_init (		/* Initialize write buffer */
+	putbuff* pb,
+	FIL* fp
+)
+{
+	pb->fp = fp;
+	pb->nchr = pb->idx = 0;
+}
+
+
+
+int f_putc (
+	TCHAR c,	/* A character to be output */
+	FIL* fp		/* Pointer to the file object */
+)
+{
+	putbuff pb;
+
+
+	putc_init(&pb, fp);
+	putc_bfd(&pb, c);	/* Put the character */
+	return putc_flush(&pb);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a string to the file                                              */
+/*-----------------------------------------------------------------------*/
+
+int f_puts (
+	const TCHAR* str,	/* Pointer to the string to be output */
+	FIL* fp				/* Pointer to the file object */
+)
+{
+	putbuff pb;
+
+
+	putc_init(&pb, fp);
+	while (*str) putc_bfd(&pb, *str++);		/* Put the string */
+	return putc_flush(&pb);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Put a formatted string to the file                                    */
+/*-----------------------------------------------------------------------*/
+
+int f_printf (
+	FIL* fp,			/* Pointer to the file object */
+	const TCHAR* fmt,	/* Pointer to the format string */
+	...					/* Optional arguments... */
+)
+{
+	va_list arp;
+	putbuff pb;
+	BYTE f, r;
+	UINT i, j, w;
+	DWORD v;
+	TCHAR c, d, str[32], *p;
+
+
+	putc_init(&pb, fp);
+
+	va_start(arp, fmt);
+
+	for (;;) {
+		c = *fmt++;
+		if (c == 0) break;			/* End of string */
+		if (c != '%') {				/* Non escape character */
+			putc_bfd(&pb, c);
+			continue;
+		}
+		w = f = 0;
+		c = *fmt++;
+		if (c == '0') {				/* Flag: '0' padding */
+			f = 1; c = *fmt++;
+		} else {
+			if (c == '-') {			/* Flag: left justified */
+				f = 2; c = *fmt++;
+			}
+		}
+		while (IsDigit(c)) {		/* Precision */
+			w = w * 10 + c - '0';
+			c = *fmt++;
+		}
+		if (c == 'l' || c == 'L') {	/* Prefix: Size is long int */
+			f |= 4; c = *fmt++;
+		}
+		if (!c) break;
+		d = c;
+		if (IsLower(d)) d -= 0x20;
+		switch (d) {				/* Type is... */
+		case 'S' :					/* String */
+			p = va_arg(arp, TCHAR*);
+			for (j = 0; p[j]; j++) ;
+			if (!(f & 2)) {
+				while (j++ < w) putc_bfd(&pb, ' ');
+			}
+			while (*p) putc_bfd(&pb, *p++);
+			while (j++ < w) putc_bfd(&pb, ' ');
+			continue;
+		case 'C' :					/* Character */
+			putc_bfd(&pb, (TCHAR)va_arg(arp, int)); continue;
+		case 'B' :					/* Binary */
+			r = 2; break;
+		case 'O' :					/* Octal */
+			r = 8; break;
+		case 'D' :					/* Signed decimal */
+		case 'U' :					/* Unsigned decimal */
+			r = 10; break;
+		case 'X' :					/* Hexdecimal */
+			r = 16; break;
+		default:					/* Unknown type (pass-through) */
+			putc_bfd(&pb, c); continue;
+		}
+
+		/* Get an argument and put it in numeral */
+		v = (f & 4) ? (DWORD)va_arg(arp, long) : ((d == 'D') ? (DWORD)(long)va_arg(arp, int) : (DWORD)va_arg(arp, unsigned int));
+		if (d == 'D' && (v & 0x80000000)) {
+			v = 0 - v;
+			f |= 8;
+		}
+		i = 0;
+		do {
+			d = (TCHAR)(v % r); v /= r;
+			if (d > 9) d += (c == 'x') ? 0x27 : 0x07;
+			str[i++] = d + '0';
+		} while (v && i < sizeof str / sizeof str[0]);
+		if (f & 8) str[i++] = '-';
+		j = i; d = (f & 1) ? '0' : ' ';
+		while (!(f & 2) && j++ < w) putc_bfd(&pb, d);
+		do putc_bfd(&pb, str[--i]); while (i);
+		while (j++ < w) putc_bfd(&pb, d);
+	}
+
+	va_end(arp);
+
+	return putc_flush(&pb);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _USE_STRFUNC */

+ 366 - 0
app/fatfs/ff.h

@@ -0,0 +1,366 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT file system module  R0.12a                             /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2016, 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.
+/----------------------------------------------------------------------------*/
+
+
+#ifndef _FATFS
+#define _FATFS	80186	/* 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 (UTF-16) 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
+
+
+
+/* Type of file size variables */
+
+#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
+
+
+
+/* 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 _USE_LFN != 0
+	WCHAR*	lfnbuf;			/* LFN working buffer */
+#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;
+
+
+
+/* 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 (invalid 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 open, set by application) */
+#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[12];			/* 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) */
+#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 problem */
+	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 the file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to the file */
+FRESULT f_lseek (FIL* fp, FSIZE_t ofs);								/* Move file pointer of the file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate the file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of the 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 a file/dir */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change timestamp of a 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 opt, DWORD au, void* work, UINT len);	/* Create a FAT 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 mode and open method flags (3rd argument of f_open) */
+#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_OPEN_APPEND		0x30
+
+/* Fast seek controls (2nd argument of f_lseek) */
+#define CREATE_LINKMAP	((FSIZE_t)0 - 1)
+
+/* Format options (2nd argument of f_mkfs) */
+#define FM_FAT		0x01
+#define FM_FAT32	0x02
+#define FM_EXFAT	0x04
+#define FM_ANY		0x07
+#define FM_SFD		0x08
+
+/* Filesystem 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 (FILINFO.fattrib) */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _FATFS */

+ 267 - 0
app/fatfs/ffconf.h

@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------/
+/  FatFs - FAT file system module configuration file
+/---------------------------------------------------------------------------*/
+
+#define _FFCONF 80186	/* Revision ID */
+
+#include "user_config.h"
+
+/*---------------------------------------------------------------------------/
+/ 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		1
+/* 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		1
+/* 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) */
+
+
+/*---------------------------------------------------------------------------/
+/ 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	3
+#define	_MAX_LFN	(FS_OBJ_NAME_LEN+1+1)
+/* 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:UTF-16)
+/  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	2
+/* 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	4
+/* Number of volumes (logical drives) to be used. */
+
+
+#define _STR_VOLUME_ID	1
+#define _VOLUME_STRS	"SD0","SD1","SD2","SD3"
+/* _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	1
+/* 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	6
+#define _NORTC_MDAY	21
+#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 ---*/

+ 38 - 0
app/fatfs/integer.h

@@ -0,0 +1,38 @@
+/*-------------------------------------------*/
+/* 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

+ 632 - 0
app/fatfs/myfatfs.c

@@ -0,0 +1,632 @@
+
+
+#include <c_stdlib.h>
+#include <c_string.h>
+
+#include "vfs_int.h"
+
+#include "fatfs_prefix_lib.h"
+#include "ff.h"
+#include "fatfs_config.h"
+
+
+static FRESULT last_result = FR_OK;
+
+static const char* const volstr[_VOLUMES] = {_VOLUME_STRS};
+
+static int is_current_drive = FALSE;
+
+
+// forward declarations
+static sint32_t myfatfs_close( const struct vfs_file *fd );
+static sint32_t myfatfs_read( const struct vfs_file *fd, void *ptr, size_t len );
+static sint32_t myfatfs_write( const struct vfs_file *fd, const void *ptr, size_t len );
+static sint32_t myfatfs_lseek( const struct vfs_file *fd, sint32_t off, int whence );
+static sint32_t myfatfs_eof( const struct vfs_file *fd );
+static sint32_t myfatfs_tell( const struct vfs_file *fd );
+static sint32_t myfatfs_flush( const struct vfs_file *fd );
+static uint32_t myfatfs_fsize( const struct vfs_file *fd );
+static sint32_t myfatfs_ferrno( const struct vfs_file *fd );
+
+static sint32_t  myfatfs_closedir( const struct vfs_dir *dd );
+static vfs_item *myfatfs_readdir( const struct vfs_dir *dd );
+
+static void        myfatfs_iclose( const struct vfs_item *di );
+static uint32_t    myfatfs_isize( const struct vfs_item *di );
+static sint32_t    myfatfs_time( const struct vfs_item *di, struct vfs_time *tm );
+static const char *myfatfs_name( const struct vfs_item *di );
+static sint32_t    myfatfs_is_dir( const struct vfs_item *di );
+static sint32_t    myfatfs_is_rdonly( const struct vfs_item *di );
+static sint32_t    myfatfs_is_hidden( const struct vfs_item *di );
+static sint32_t    myfatfs_is_sys( const struct vfs_item *di );
+static sint32_t    myfatfs_is_arch( const struct vfs_item *di );
+
+static vfs_vol  *myfatfs_mount( const char *name, int num );
+static vfs_file *myfatfs_open( const char *name, const char *mode );
+static vfs_dir  *myfatfs_opendir( const char *name );
+static vfs_item *myfatfs_stat( const char *name );
+static sint32_t  myfatfs_remove( const char *name );
+static sint32_t  myfatfs_rename( const char *oldname, const char *newname );
+static sint32_t  myfatfs_mkdir( const char *name );
+static sint32_t  myfatfs_fsinfo( uint32_t *total, uint32_t *used );
+static sint32_t  myfatfs_chdrive( const char *name );
+static sint32_t  myfatfs_chdir( const char *name );
+static sint32_t  myfatfs_errno( void );
+static void      myfatfs_clearerr( void );
+
+static sint32_t myfatfs_umount( const struct vfs_vol *vol );
+
+
+// ---------------------------------------------------------------------------
+// function tables
+//
+static vfs_fs_fns myfatfs_fs_fns = {
+  .mount    = myfatfs_mount,
+  .open     = myfatfs_open,
+  .opendir  = myfatfs_opendir,
+  .stat     = myfatfs_stat,
+  .remove   = myfatfs_remove,
+  .rename   = myfatfs_rename,
+  .mkdir    = myfatfs_mkdir,
+  .fsinfo   = myfatfs_fsinfo,
+  .fscfg    = NULL,
+  .format   = NULL,
+  .chdrive  = myfatfs_chdrive,
+  .chdir    = myfatfs_chdir,
+  .ferrno   = myfatfs_errno,
+  .clearerr = myfatfs_clearerr
+};
+
+static vfs_file_fns myfatfs_file_fns = {
+  .close     = myfatfs_close,
+  .read      = myfatfs_read,
+  .write     = myfatfs_write,
+  .lseek     = myfatfs_lseek,
+  .eof       = myfatfs_eof,
+  .tell      = myfatfs_tell,
+  .flush     = myfatfs_flush,
+  .size      = myfatfs_fsize,
+  .ferrno    = myfatfs_ferrno
+};
+
+static vfs_item_fns myfatfs_item_fns = {
+  .close     = myfatfs_iclose,
+  .size      = myfatfs_isize,
+  .time      = myfatfs_time,
+  .name      = myfatfs_name,
+  .is_dir    = myfatfs_is_dir,
+  .is_rdonly = myfatfs_is_rdonly,
+  .is_hidden = myfatfs_is_hidden,
+  .is_sys    = myfatfs_is_sys,
+  .is_arch   = myfatfs_is_arch
+};
+
+static vfs_dir_fns myfatfs_dir_fns = {
+  .close     = myfatfs_closedir,
+  .readdir   = myfatfs_readdir
+};
+
+static vfs_vol_fns myfatfs_vol_fns = {
+  .umount    = myfatfs_umount
+};
+
+
+// ---------------------------------------------------------------------------
+// specific struct extensions
+//
+struct myvfs_vol {
+  struct vfs_vol vfs_vol;
+  char *ldrname;
+  FATFS fs;
+};
+
+struct myvfs_file {
+  struct vfs_file vfs_file;
+  FIL fp;
+};
+
+struct myvfs_dir {
+  struct vfs_dir vfs_dir;
+  DIR dp;
+};
+
+struct myvfs_item {
+  struct vfs_item vfs_item;
+  FILINFO fno;
+};
+
+
+// ---------------------------------------------------------------------------
+// exported helper functions for FatFS
+//
+inline void *ff_memalloc( UINT size )
+{
+  return c_malloc( size );
+}
+
+inline void ff_memfree( void *mblock )
+{
+  c_free( mblock );
+}
+
+// TODO
+DWORD get_fattime( void )
+{
+  DWORD stamp;
+  vfs_time tm;
+
+  if (VFS_RES_OK == vfs_get_rtc( &tm )) {
+    // sanity checks
+    tm.year = (tm.year >= 1980) && (tm.year < 2108) ? tm.year : 1980;
+    tm.mon  = (tm.mon  >= 1) && (tm.mon  <= 12) ? tm.mon  : 1;
+    tm.day  = (tm.day  >= 1) && (tm.day  <= 31) ? tm.day  : 1;
+    tm.hour = (tm.hour >= 0) && (tm.hour <= 23) ? tm.hour : 0;
+    tm.min  = (tm.min  >= 0) && (tm.min  <= 59) ? tm.min  : 0;
+    tm.sec  = (tm.sec  >= 0) && (tm.sec  <= 59) ? tm.sec  : 0;
+
+    stamp = (tm.year-1980) << 25 | tm.mon << 21 | tm.day << 16 |
+            tm.hour << 11 | tm.min << 5 | tm.sec;
+  } else {
+    // default time stamp derived from ffconf.h
+    stamp = ((DWORD)(_NORTC_YEAR - 1980) << 25 | (DWORD)_NORTC_MON << 21 | (DWORD)_NORTC_MDAY << 16);
+  }
+
+  return stamp;
+}
+
+
+// ---------------------------------------------------------------------------
+// volume functions
+//
+#define GET_FATFS_FS(descr) \
+  const struct myvfs_vol *myvol = (const struct myvfs_vol *)descr; \
+  FATFS *fs = (FATFS *)&(myvol->fs);
+
+static sint32_t myfatfs_umount( const struct vfs_vol *vol )
+{
+  GET_FATFS_FS(vol);
+
+  last_result = f_mount( NULL, myvol->ldrname, 0 );
+
+  c_free( myvol->ldrname );
+  c_free( (void *)vol );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+
+// ---------------------------------------------------------------------------
+// file functions
+//
+#define GET_FIL_FP(descr) \
+  const struct myvfs_file *myfd = (const struct myvfs_file *)descr; \
+  FIL *fp = (FIL *)&(myfd->fp);
+
+static sint32_t myfatfs_close( const struct vfs_file *fd )
+{
+  GET_FIL_FP(fd)
+
+  last_result = f_close( fp );
+
+  // free descriptor memory
+  c_free( (void *)fd );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_read( const struct vfs_file *fd, void *ptr, size_t len )
+{
+  GET_FIL_FP(fd);
+  UINT act_read;
+
+  last_result = f_read( fp, ptr, len, &act_read );
+
+  return last_result == FR_OK ? act_read : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_write( const struct vfs_file *fd, const void *ptr, size_t len )
+{
+  GET_FIL_FP(fd);
+  UINT act_written;
+
+  last_result = f_write( fp, ptr, len, &act_written );
+
+  return last_result == FR_OK ? act_written : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_lseek( const struct vfs_file *fd, sint32_t off, int whence )
+{
+  GET_FIL_FP(fd);
+  FSIZE_t new_pos;
+
+  switch (whence) {
+  default:
+  case VFS_SEEK_SET:
+    new_pos = off > 0 ? off : 0;
+    break;
+  case VFS_SEEK_CUR:
+    new_pos = f_tell( fp );
+    new_pos += off;
+    break;
+  case VFS_SEEK_END:
+    new_pos = f_size( fp );
+    new_pos += off < 0 ? off : 0;
+    break;
+  };
+
+  last_result = f_lseek( fp, new_pos );
+  new_pos = f_tell( fp );
+
+  return last_result == FR_OK ? new_pos : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_eof( const struct vfs_file *fd )
+{
+  GET_FIL_FP(fd);
+
+  last_result = FR_OK;
+
+  return f_eof( fp );
+}
+
+static sint32_t myfatfs_tell( const struct vfs_file *fd )
+{
+  GET_FIL_FP(fd);
+
+  last_result = FR_OK;
+
+  return f_tell( fp );
+}
+
+static sint32_t myfatfs_flush( const struct vfs_file *fd )
+{
+  GET_FIL_FP(fd);
+
+  last_result = f_sync( fp );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static uint32_t myfatfs_fsize( const struct vfs_file *fd )
+{
+  GET_FIL_FP(fd);
+
+  last_result = FR_OK;
+
+  return f_size( fp );
+}
+
+static sint32_t myfatfs_ferrno( const struct vfs_file *fd )
+{
+  return -last_result;
+}
+
+
+// ---------------------------------------------------------------------------
+// dir functions
+//
+#define GET_DIR_DP(descr) \
+  const struct myvfs_dir *mydd = (const struct myvfs_dir *)descr; \
+  DIR *dp = (DIR *)&(mydd->dp);
+
+static sint32_t myfatfs_closedir( const struct vfs_dir *dd )
+{
+  GET_DIR_DP(dd);
+
+  last_result = f_closedir( dp );
+
+  // free descriptor memory
+  c_free( (void *)dd );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static vfs_item *myfatfs_readdir( const struct vfs_dir *dd )
+{
+  GET_DIR_DP(dd);
+  struct myvfs_item *di;
+
+  if (di = c_malloc( sizeof( struct myvfs_item ) )) {
+    FILINFO *fno = &(di->fno);
+
+    if (FR_OK == (last_result = f_readdir( dp, fno ))) {
+      // condition "no further item" is signalled with empty name
+      if (fno->fname[0] != '\0') {
+        di->vfs_item.fs_type = VFS_FS_FATFS;
+        di->vfs_item.fns     = &myfatfs_item_fns;
+        return (vfs_item *)di;
+      }
+    }
+    c_free( di );
+  }
+
+  return NULL;
+}
+
+
+// ---------------------------------------------------------------------------
+// dir info functions
+//
+#define GET_FILINFO_FNO(descr) \
+  const struct myvfs_item *mydi = (const struct myvfs_item *)descr; \
+  FILINFO *fno = (FILINFO *)&(mydi->fno);
+
+static void myfatfs_iclose( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  // free descriptor memory
+  c_free( (void *)di );
+}
+
+static uint32_t myfatfs_isize( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fsize;
+}
+
+static sint32_t myfatfs_time( const struct vfs_item *di, struct vfs_time *tm )
+{
+  GET_FILINFO_FNO(di);
+
+  tm->year = (fno->fdate >>  9) + 1980;
+  tm->mon  = (fno->fdate >>  5) & 0x0f;
+  tm->day  =  fno->fdate        & 0x1f;
+  tm->hour = (fno->ftime >> 11);
+  tm->min  = (fno->ftime >>  5) & 0x3f;
+  tm->sec  =  fno->ftime        & 0x3f;
+
+  return VFS_RES_OK;
+}
+
+static const char *myfatfs_name( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fname;
+}
+
+static sint32_t myfatfs_is_dir( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fattrib & AM_DIR ? 1 : 0;
+}
+
+static sint32_t myfatfs_is_rdonly( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fattrib & AM_RDO ? 1 : 0;
+}
+
+static sint32_t myfatfs_is_hidden( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fattrib & AM_HID ? 1 : 0;
+}
+
+static sint32_t myfatfs_is_sys( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fattrib & AM_SYS ? 1 : 0;
+}
+
+static sint32_t myfatfs_is_arch( const struct vfs_item *di )
+{
+  GET_FILINFO_FNO(di);
+
+  return fno->fattrib & AM_ARC ? 1 : 0;
+}
+
+
+// ---------------------------------------------------------------------------
+// filesystem functions
+//
+static vfs_vol *myfatfs_mount( const char *name, int num )
+{
+  struct myvfs_vol *vol;
+  const size_t len = c_strlen( name );
+
+  // num argument specifies the physical driver = SS/CS pin number for this sd card
+  if (num >= 0) {
+    for (int i = 0; i < NUM_LOGICAL_DRIVES; i++) {
+      if (0 == c_strncmp( name, volstr[i], c_strlen( volstr[i] ) )) {
+        VolToPart[i].pd = num;
+      }
+    }
+  }
+
+  if (vol = c_malloc( sizeof( struct myvfs_vol ) )) {
+    if (vol->ldrname = c_strdup( name )) {
+      if (FR_OK == (last_result = f_mount( &(vol->fs), name, 1 ))) {
+	vol->vfs_vol.fs_type = VFS_FS_FATFS;
+	vol->vfs_vol.fns     = &myfatfs_vol_fns;
+	return (vfs_vol *)vol;
+      }
+    }
+  }
+
+  if (vol) {
+    if (vol->ldrname) c_free( vol->ldrname );
+    c_free( vol );
+  }
+  return NULL;
+}
+
+static BYTE myfatfs_mode2flag( const char *mode )
+{
+  if (c_strlen( mode ) == 1) {
+    if(c_strcmp( mode, "w" ) == 0)
+      return FA_WRITE | FA_CREATE_ALWAYS;
+    else if (c_strcmp( mode, "r" ) == 0)
+      return FA_READ | FA_OPEN_EXISTING;
+    else if (c_strcmp( mode, "a" ) == 0)
+      return FA_WRITE | FA_OPEN_ALWAYS;
+    else
+      return FA_READ | FA_OPEN_EXISTING;
+  } else if (c_strlen( mode ) == 2) {
+    if (c_strcmp( mode, "r+" ) == 0)
+      return FA_READ | FA_WRITE | FA_OPEN_EXISTING;
+    else if (c_strcmp( mode, "w+" ) == 0)
+      return FA_READ | FA_WRITE | FA_CREATE_ALWAYS;
+    else if (c_strcmp( mode, "a+" ) ==0 )
+      return FA_READ | FA_WRITE | FA_OPEN_ALWAYS;
+    else
+      return FA_READ | FA_OPEN_EXISTING;
+  } else {
+    return FA_READ | FA_OPEN_EXISTING;
+  }
+}
+
+static vfs_file *myfatfs_open( const char *name, const char *mode )
+{
+  struct myvfs_file *fd;
+  const BYTE flags = myfatfs_mode2flag( mode );
+
+  if (fd = c_malloc( sizeof( struct myvfs_file ) )) {
+    if (FR_OK == (last_result = f_open( &(fd->fp), name, flags ))) {
+      // skip to end of file for append mode
+      if (flags & FA_OPEN_ALWAYS)
+        f_lseek( &(fd->fp), f_size( &(fd->fp) ) );
+
+      fd->vfs_file.fs_type = VFS_FS_FATFS;
+      fd->vfs_file.fns     = &myfatfs_file_fns;
+      return (vfs_file *)fd;
+    } else {
+      c_free( fd );
+    }
+  }
+
+  return NULL;
+}
+
+static vfs_dir *myfatfs_opendir( const char *name )
+{
+  struct myvfs_dir *dd;
+
+  if (dd = c_malloc( sizeof( struct myvfs_dir ) )) {
+    if (FR_OK == (last_result = f_opendir( &(dd->dp), name ))) {
+      dd->vfs_dir.fs_type = VFS_FS_FATFS;
+      dd->vfs_dir.fns     = &myfatfs_dir_fns;
+      return (vfs_dir *)dd;
+    } else {
+      c_free( dd );
+    }
+  }
+
+  return NULL;
+}
+
+static vfs_item *myfatfs_stat( const char *name )
+{
+  struct myvfs_item *di;
+
+  if (di = c_malloc( sizeof( struct myvfs_item ) )) {
+    if (FR_OK == (last_result = f_stat( name, &(di->fno) ))) {
+      di->vfs_item.fs_type = VFS_FS_FATFS;
+      di->vfs_item.fns     = &myfatfs_item_fns;
+      return (vfs_item *)di;
+    } else {
+      c_free( di );
+    }
+  }
+
+  return NULL;
+}
+
+static sint32_t myfatfs_remove( const char *name )
+{
+  last_result = f_unlink( name );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_rename( const char *oldname, const char *newname )
+{
+  last_result = f_rename( oldname, newname );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_mkdir( const char *name )
+{
+  last_result = f_mkdir( name );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t  myfatfs_fsinfo( uint32_t *total, uint32_t *used )
+{
+  DWORD free_clusters;
+  FATFS *fatfs;
+
+  if ((last_result = f_getfree( "", &free_clusters, &fatfs )) == FR_OK) {
+    // provide information in kByte since uint32_t would clip to 4 GByte
+    *total = (fatfs->n_fatent * fatfs->csize) / (1024 / _MAX_SS);
+    *used  = *total - (free_clusters * fatfs->csize) / (1024 / _MAX_SS);
+  }
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_chdrive( const char *name )
+{
+  last_result = f_chdrive( name );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_chdir( const char *name )
+{
+  last_result = f_chdir( name );
+
+  return last_result == FR_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+static sint32_t myfatfs_errno( void )
+{
+  return -last_result;
+}
+
+static void myfatfs_clearerr( void )
+{
+  last_result = FR_OK;
+}
+
+
+// ---------------------------------------------------------------------------
+// VFS interface functions
+//
+vfs_fs_fns *myfatfs_realm( const char *inname, char **outname, int set_current_drive )
+{
+  if (inname[0] == '/') {
+    char *oname;
+
+    // logical drive is specified, check if it's one of ours
+    for (int i = 0; i < _VOLUMES; i++) {
+      size_t volstr_len = c_strlen( volstr[i] );
+      if (0 == c_strncmp( &(inname[1]), volstr[i], volstr_len )) {
+        oname = c_strdup( inname );
+        c_strcpy( oname, volstr[i] );
+        oname[volstr_len] = ':';
+        *outname = oname;
+
+        if (set_current_drive) is_current_drive = TRUE;
+        return &myfatfs_fs_fns;
+      }
+    }
+  } else {
+    // no logical drive in patchspec, are we current drive?
+    if (is_current_drive) {
+      *outname = c_strdup( inname );
+      return &myfatfs_fs_fns;
+    }
+  }
+
+  if (set_current_drive) is_current_drive = FALSE;
+  return NULL;
+}

+ 49 - 0
app/fatfs/option/Makefile

@@ -0,0 +1,49 @@
+
+#############################################################
+# Required variables for each makefile
+# Discard this section from all parent makefiles
+# Expected variables (with automatic defaults):
+#   CSRCS (all "C" files in the dir)
+#   SUBDIRS (all subdirs with a Makefile)
+#   GEN_LIBS - list of libs to be generated ()
+#   GEN_IMAGES - list of images to be generated ()
+#   COMPONENTS_xxx - a list of libs/objs in the form
+#     subdir/lib to be extracted and rolled up into
+#     a generated lib/image xxx.a ()
+#
+ifndef PDIR
+
+GEN_LIBS = liboption.a
+CSRCS = unicode.c
+
+endif
+
+FATFS_INC_DIR = ../
+
+#############################################################
+# Configuration i.e. compile options etc.
+# Target specific stuff (defines etc.) goes in here!
+# Generally values applying to a tree are captured in the
+#   makefile at its root level - these are then overridden
+#   for a subtree within the makefile rooted therein
+#
+#DEFINES += 
+
+#############################################################
+# Recursion Magic - Don't touch this!!
+#
+# Each subtree potentially has an include directory
+#   corresponding to the common APIs applicable to modules
+#   rooted at that subtree. Accordingly, the INCLUDE PATH
+#   of a module can only contain the include directories up
+#   its parent path, and not its siblings
+#
+# Required for each makefile to inherit from the parent
+#
+
+INCLUDES := $(INCLUDES) -I $(PDIR)include
+INCLUDES += -I ./
+INCLUDES += -I ../../platform
+PDIR := ../$(PDIR)
+sinclude $(PDIR)Makefile
+

Plik diff jest za duży
+ 3797 - 0
app/fatfs/option/cc932.c


Plik diff jest za duży
+ 10972 - 0
app/fatfs/option/cc936.c


Plik diff jest za duży
+ 8601 - 0
app/fatfs/option/cc949.c


Plik diff jest za duży
+ 6827 - 0
app/fatfs/option/cc950.c


Plik diff jest za duży
+ 315 - 0
app/fatfs/option/ccsbcs.c


+ 151 - 0
app/fatfs/option/syscall.c

@@ -0,0 +1,151 @@
+/*------------------------------------------------------------------------*/
+/* Sample code of OS dependent controls for FatFs                         */
+/* (C)ChaN, 2014                                                          */
+/*------------------------------------------------------------------------*/
+
+
+#include "../ff.h"
+
+
+#if _FS_REENTRANT
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to create a new
+/  synchronization object, such as semaphore and mutex. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_cre_syncobj (	/* 1:Function succeeded, 0:Could not create the sync object */
+	BYTE vol,			/* Corresponding volume (logical drive number) */
+	_SYNC_t *sobj		/* Pointer to return the created sync object */
+)
+{
+	int ret;
+
+
+	*sobj = CreateMutex(NULL, FALSE, NULL);		/* Win32 */
+	ret = (int)(*sobj != INVALID_HANDLE_VALUE);
+
+//	*sobj = SyncObjects[vol];			/* uITRON (give a static sync object) */
+//	ret = 1;							/* The initial value of the semaphore must be 1. */
+
+//	*sobj = OSMutexCreate(0, &err);		/* uC/OS-II */
+//	ret = (int)(err == OS_NO_ERR);
+
+//	*sobj = xSemaphoreCreateMutex();	/* FreeRTOS */
+//	ret = (int)(*sobj != NULL);
+
+	return ret;
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj() function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_del_syncobj (	/* 1:Function succeeded, 0:Could not delete due to any error */
+	_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
+)
+{
+	int ret;
+
+
+	ret = CloseHandle(sobj);	/* Win32 */
+
+//	ret = 1;					/* uITRON (nothing to do) */
+
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);	/* uC/OS-II */
+//	ret = (int)(err == OS_NO_ERR);
+
+//  vSemaphoreDelete(sobj);		/* FreeRTOS */
+//	ret = 1;
+
+	return ret;
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on entering file functions to lock the volume.
+/  When a 0 is returned, the file function fails with FR_TIMEOUT.
+*/
+
+int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	_SYNC_t sobj	/* Sync object to wait */
+)
+{
+	int ret;
+
+	ret = (int)(WaitForSingleObject(sobj, _FS_TIMEOUT) == WAIT_OBJECT_0);	/* Win32 */
+
+//	ret = (int)(wai_sem(sobj) == E_OK);			/* uITRON */
+
+//	OSMutexPend(sobj, _FS_TIMEOUT, &err));		/* uC/OS-II */
+//	ret = (int)(err == OS_NO_ERR);
+
+//	ret = (int)(xSemaphoreTake(sobj, _FS_TIMEOUT) == pdTRUE);	/* FreeRTOS */
+
+	return ret;
+}
+
+
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on leaving file functions to unlock the volume.
+*/
+
+void ff_rel_grant (
+	_SYNC_t sobj	/* Sync object to be signaled */
+)
+{
+	ReleaseMutex(sobj);		/* Win32 */
+
+//	sig_sem(sobj);			/* uITRON */
+
+//	OSMutexPost(sobj);		/* uC/OS-II */
+
+//	xSemaphoreGive(sobj);	/* FreeRTOS */
+}
+
+#endif
+
+
+
+
+#if _USE_LFN == 3	/* LFN with a working buffer on the heap */
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+/* If a NULL is returned, the file function fails with FR_NOT_ENOUGH_CORE.
+*/
+
+void* ff_memalloc (	/* Returns pointer to the allocated memory block */
+	UINT msize		/* Number of bytes to allocate */
+)
+{
+	return malloc(msize);	/* Allocate a new memory block with POSIX API */
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
+void ff_memfree (
+	void* mblock	/* Pointer to the memory block to free */
+)
+{
+	free(mblock);	/* Discard the memory block with POSIX API */
+}
+
+#endif

+ 17 - 0
app/fatfs/option/unicode.c

@@ -0,0 +1,17 @@
+#include "../ff.h"
+
+#if _USE_LFN != 0
+
+#if   _CODE_PAGE == 932	/* Japanese Shift_JIS */
+#include "cc932.c"
+#elif _CODE_PAGE == 936	/* Simplified Chinese GBK */
+#include "cc936.c"
+#elif _CODE_PAGE == 949	/* Korean */
+#include "cc949.c"
+#elif _CODE_PAGE == 950	/* Traditional Chinese Big5 */
+#include "cc950.c"
+#else					/* Single Byte Character-Set */
+#include "ccsbcs.c"
+#endif
+
+#endif

+ 9 - 0
app/include/driver/spi.h

@@ -11,6 +11,9 @@
 #define SPI 			0
 #define HSPI			1
 
+#define SPI_ORDER_LSB 0
+#define SPI_ORDER_MSB 1
+
 
 
 //lcd drive function
@@ -18,7 +21,13 @@ void spi_lcd_mode_init(uint8 spi_no);
 void spi_lcd_9bit_write(uint8 spi_no,uint8 high_bit,uint8 low_8bit);
 
 //spi master init funtion
+uint32_t spi_set_clkdiv(uint8 spi_no, uint32_t clock_div);
 void spi_master_init(uint8 spi_no, unsigned cpol, unsigned cpha, uint32_t clock_div);
+void spi_mast_byte_order(uint8 spi_no, uint8 order);
+// blocked buffer write
+void spi_mast_blkset(uint8 spi_no, size_t bitlen, const uint8 *data);
+// blocked buffer read
+void spi_mast_blkget(uint8 spi_no, size_t bitlen, uint8 *data);
 // fill MOSI buffer
 void spi_mast_set_mosi(uint8 spi_no, uint16 offset, uint8 bitlen, uint32 data);
 // retrieve data from MISO buffer

+ 24 - 0
app/include/fatfs_config.h

@@ -0,0 +1,24 @@
+#ifndef __FATFS_CONFIG_H__
+#define __FATFS_CONFIG_H__
+
+
+// don't redefine the PARTITION type
+#ifndef _FATFS
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+#endif
+
+// Table to map physical drive & partition to a logical volume.
+// The first value is the physical drive and contains the GPIO pin for SS/CS of the SD card (default pin 8)
+// The second value is the partition number.
+#define NUM_LOGICAL_DRIVES 4
+PARTITION VolToPart[NUM_LOGICAL_DRIVES] = {
+  {8, 1},   /* Logical drive "0:" ==> SS pin 8, 1st partition */
+  {8, 2},   /* Logical drive "1:" ==> SS pin 8, 2st partition */
+  {8, 3},   /* Logical drive "2:" ==> SS pin 8, 3st partition */
+  {8, 4}    /* Logical drive "3:" ==> SS pin 8, 4st partition */
+};
+
+#endif	/* __FATFS_CONFIG_H__ */

+ 6 - 1
app/include/user_config.h

@@ -68,9 +68,14 @@ extern void luaL_assertfail(const char *file, int line, const char *message);
 //#define MD2_ENABLE
 #define SHA2_ENABLE
 
-#define BUILD_SPIFFS	1
+#define BUILD_SPIFFS
 #define SPIFFS_CACHE 1
 
+//#define BUILD_FATFS
+
+// maximum length of a filename
+#define FS_OBJ_NAME_LEN 31
+
 // Uncomment this next line for fastest startup 
 // It reduces the format time dramatically
 // #define SPIFFS_MAX_FILESYSTEM_SIZE	32768

+ 14 - 14
app/lua/lauxlib.c

@@ -13,7 +13,7 @@
 #include C_HEADER_STDLIB
 #include C_HEADER_STRING
 #ifndef LUA_CROSS_COMPILER
-#include "flash_fs.h"
+#include "vfs.h"
 #else
 #endif
 
@@ -671,8 +671,8 @@ static const char *getFSF (lua_State *L, void *ud, size_t *size) {
     return "\n";
   }
 
-  if (fs_eof(lf->f)) return NULL;
-  *size = fs_read(lf->f, lf->buff, sizeof(lf->buff));
+  if (vfs_eof(lf->f)) return NULL;
+  *size = vfs_read(lf->f, lf->buff, sizeof(lf->buff));
 
   return (*size > 0) ? lf->buff : NULL;
 }
@@ -697,29 +697,29 @@ LUALIB_API int luaL_loadfsfile (lua_State *L, const char *filename) {
   }
   else {
     lua_pushfstring(L, "@%s", filename);
-    lf.f = fs_open(filename, FS_RDONLY);
-    if (lf.f < FS_OPEN_OK) return errfsfile(L, "open", fnameindex);
+    lf.f = vfs_open(filename, "r");
+    if (!lf.f) return errfsfile(L, "open", fnameindex);
   }
   // if(fs_size(lf.f)>LUAL_BUFFERSIZE)
   //   return luaL_error(L, "file is too big");
-  c = fs_getc(lf.f);
+  c = vfs_getc(lf.f);
   if (c == '#') {  /* Unix exec. file? */
     lf.extraline = 1;
-    while ((c = fs_getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
-    if (c == '\n') c = fs_getc(lf.f);
+    while ((c = vfs_getc(lf.f)) != VFS_EOF && c != '\n') ;  /* skip first line */
+    if (c == '\n') c = vfs_getc(lf.f);
   }
   if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
-    fs_close(lf.f);
-    lf.f = fs_open(filename, FS_RDONLY);  /* reopen in binary mode */
-    if (lf.f < FS_OPEN_OK) return errfsfile(L, "reopen", fnameindex);
+    vfs_close(lf.f);
+    lf.f = vfs_open(filename, "r");  /* reopen in binary mode */
+    if (!lf.f) return errfsfile(L, "reopen", fnameindex);
     /* skip eventual `#!...' */
-   while ((c = fs_getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
+   while ((c = vfs_getc(lf.f)) != VFS_EOF && c != LUA_SIGNATURE[0]) ;
     lf.extraline = 0;
   }
-  fs_ungetc(c, lf.f);
+  vfs_ungetc(c, lf.f);
   status = lua_load(L, getFSF, &lf, lua_tostring(L, -1));
 
-  if (filename) fs_close(lf.f);  /* close file (even in case of errors) */
+  if (filename) vfs_close(lf.f);  /* close file (even in case of errors) */
   lua_remove(L, fnameindex);
   return status;
 }

+ 23 - 23
app/lua/liolib.c

@@ -9,7 +9,7 @@
 #include "c_stdio.h"
 #include "c_stdlib.h"
 #include "c_string.h"
-#include "flash_fs.h"
+#include "vfs.h"
 
 #define liolib_c
 #define LUA_LIB
@@ -39,7 +39,7 @@ static const int liolib_keys[] = {(int)&luaL_callmeta, (int)&luaL_typerror, (int
 static const char *const fnames[] = {"input", "output"};
 
 static int pushresult (lua_State *L, int i, const char *filename) {
-  int en = fs_error(0);  /* calls to Lua API may change this value */
+  int en = vfs_ferrno(0);  /* calls to Lua API may change this value */
   if (i) {
     lua_pushboolean(L, 1);
     return 1;
@@ -57,7 +57,7 @@ static int pushresult (lua_State *L, int i, const char *filename) {
 
 
 static void fileerror (lua_State *L, int arg, const char *filename) {
-  lua_pushfstring(L, "%s: err(%d)", filename, fs_error(0));
+  lua_pushfstring(L, "%s: err(%d)", filename, vfs_ferrno(0));
   luaL_argerror(L, arg, lua_tostring(L, -1));
 }
 
@@ -130,7 +130,7 @@ static int io_pclose (lua_State *L) {
 */
 static int io_fclose (lua_State *L) {
   int *p = tofilep(L);
-  int ok = (fs_close(*p) == 0);
+  int ok = (vfs_close(*p) == 0);
   *p = FS_OPEN_OK - 1;
   return pushresult(L, ok, NULL);
 }
@@ -149,7 +149,7 @@ static int aux_close (lua_State *L) {
     lua_pushliteral(L, "cannot close standard file");
     return 2;  
   }
-  int ok = (fs_close(*p) == 0);
+  int ok = (vfs_close(*p) == 0);
   *p = FS_OPEN_OK - 1;
   return pushresult(L, ok, NULL);
 #endif 
@@ -187,7 +187,7 @@ static int io_open (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
   int *pf = newfile(L);
-  *pf = fs_open(filename, fs_mode2flag(mode));
+  *pf = vfs_open(filename, mode);
   return (*pf == FS_OPEN_OK - 1) ? pushresult(L, 0, filename) : 1;
 }
 
@@ -201,7 +201,7 @@ static int io_popen (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
   int *pf = newfile(L);
-  *pf = lua_popen(L, filename, fs_mode2flag(mode));
+  *pf = lua_popen(L, filename, fs_mode2flags(mode));
   return (*pf == FS_OPEN_OK - 1) ? pushresult(L, 0, filename) : 1;
 }
 
@@ -230,7 +230,7 @@ static int g_iofile (lua_State *L, int f, const char *mode) {
     const char *filename = lua_tostring(L, 1);
     if (filename) {
       int *pf = newfile(L);
-      *pf = fs_open(filename, fs_mode2flag(mode));
+      *pf = vfs_open(filename, mode);
       if (*pf == FS_OPEN_OK - 1)
         fileerror(L, 1, filename);
     }
@@ -282,7 +282,7 @@ static int io_lines (lua_State *L) {
   else {
     const char *filename = luaL_checkstring(L, 1);
     int *pf = newfile(L);
-    *pf = fs_open(filename, FS_RDONLY);
+    *pf = vfs_open(filename, "r");
     if (*pf == FS_OPEN_OK - 1)
       fileerror(L, 1, filename);
     aux_lines(L, lua_gettop(L), 1);
@@ -312,8 +312,8 @@ static int read_number (lua_State *L, int f) {
 #endif
 
 static int test_eof (lua_State *L, int f) {
-  int c = fs_getc(f);
-  fs_ungetc(c, f);
+  int c = vfs_getc(f);
+  vfs_ungetc(c, f);
   lua_pushlstring(L, NULL, 0);
   return (c != EOF);
 }
@@ -347,7 +347,7 @@ static int read_line (lua_State *L, int f) {
   signed char c = EOF;
   int i = 0;
   do{
-    c = (signed char)fs_getc(f);
+    c = (signed char)vfs_getc(f);
     if(c==EOF){
       break;
     }
@@ -377,7 +377,7 @@ static int read_chars (lua_State *L, int f, size_t n) {
   do {
     char *p = luaL_prepbuffer(&b);
     if (rlen > n) rlen = n;  /* cannot read more than asked */
-    nr = fs_read(f, p, rlen);
+    nr = vfs_read(f, p, rlen);
     luaL_addsize(&b, nr);
     n -= nr;  /* still have to read `n' chars */
   } while (n > 0 && nr == rlen);  /* until end of count or eof */
@@ -390,7 +390,7 @@ static int g_read (lua_State *L, int f, int first) {
   int nargs = lua_gettop(L) - 1;
   int success;
   int n;
-  fs_clearerr(f);
+  //vfs_clearerr(f);
   if (nargs == 0) {  /* no arguments? */
     success = read_line(L, f);
     n = first+1;  /* to return 1 result */
@@ -425,7 +425,7 @@ static int g_read (lua_State *L, int f, int first) {
       }
     }
   }
-  if (fs_error(f))
+  if (vfs_ferrno(f))
     return pushresult(L, 0, NULL);
   if (!success) {
     lua_pop(L, 1);  /* remove last result */
@@ -453,8 +453,8 @@ static int io_readline (lua_State *L) {
     return 0;
   }
   sucess = read_line(L, *pf);
-  if (fs_error(*pf))
-    return luaL_error(L, "err(%d)", fs_error(*pf));
+  if (vfs_ferrno(*pf))
+    return luaL_error(L, "err(%d)", vfs_ferrno(*pf));
   if (sucess) return 1;
   else {  /* EOF */
     if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
@@ -484,7 +484,7 @@ static int g_write (lua_State *L, int f, int arg) {
     {
       size_t l;
       const char *s = luaL_checklstring(L, arg, &l);
-      status = status && (fs_write(f, s, l) == l);
+      status = status && (vfs_write(f, s, l) == l);
     }
   }
   return pushresult(L, status, NULL);
@@ -502,16 +502,16 @@ static int f_write (lua_State *L) {
 
 
 static int f_seek (lua_State *L) {
-  static const int mode[] = {FS_SEEK_SET, FS_SEEK_CUR, FS_SEEK_END};
+  static const int mode[] = {VFS_SEEK_SET, VFS_SEEK_CUR, VFS_SEEK_END};
   static const char *const modenames[] = {"set", "cur", "end", NULL};
   int f = tofile(L);
   int op = luaL_checkoption(L, 2, "cur", modenames);
   long offset = luaL_optlong(L, 3, 0);
-  op = fs_seek(f, offset, mode[op]);
+  op = vfs_lseek(f, offset, mode[op]);
   if (op)
     return pushresult(L, 0, NULL);  /* error */
   else {
-    lua_pushinteger(L, fs_tell(f));
+    lua_pushinteger(L, vfs_tell(f));
     return 1;
   }
 }
@@ -530,12 +530,12 @@ static int f_setvbuf (lua_State *L) {
 
 
 static int io_flush (lua_State *L) {
-  return pushresult(L, fs_flush(getiofile(L, IO_OUTPUT)) == 0, NULL);
+  return pushresult(L, vfs_flush(getiofile(L, IO_OUTPUT)) == 0, NULL);
 }
 
 
 static int f_flush (lua_State *L) {
-  return pushresult(L, fs_flush(tofile(L)) == 0, NULL);
+  return pushresult(L, vfs_flush(tofile(L)) == 0, NULL);
 }
 
 #undef MIN_OPT_LEVEL

+ 4 - 4
app/lua/loadlib.c

@@ -19,7 +19,7 @@
 #include C_HEADER_FCNTL
 
 #ifndef LUA_CROSS_COMPILER
-#include "flash_fs.h"
+#include "vfs.h"
 #endif
 
 #include "lauxlib.h"
@@ -340,9 +340,9 @@ static int readable (const char *filename) {
 }
 #else
 static int readable (const char *filename) {
-  int f = fs_open(filename, FS_RDONLY);  /* try to open file */
-  if (f < FS_OPEN_OK) return 0;  /* open failed */
-  fs_close(f);
+  int f = vfs_open(filename, "r");  /* try to open file */
+  if (!f) return 0;  /* open failed */
+  vfs_close(f);
   return 1;
 }
 #endif

+ 1 - 1
app/lua/lua.c

@@ -9,7 +9,7 @@
 #include "c_stdio.h"
 #include "c_stdlib.h"
 #include "c_string.h"
-#include "flash_fs.h"
+#include "user_interface.h"
 #include "user_version.h"
 #include "driver/readline.h"
 #include "driver/uart.h"

+ 1 - 0
app/modules/Makefile

@@ -52,6 +52,7 @@ INCLUDES += -I ../spiffs
 INCLUDES += -I ../smart
 INCLUDES += -I ../cjson
 INCLUDES += -I ../dhtlib
+INCLUDES += -I ../fatfs
 INCLUDES += -I ../http
 INCLUDES += -I ../websocket
 PDIR := ../$(PDIR)

+ 10 - 5
app/modules/crypto.c

@@ -6,7 +6,7 @@
 #include "platform.h"
 #include "c_types.h"
 #include "c_stdlib.h"
-#include "flash_fs.h"
+#include "vfs.h"
 #include "../crypto/digests.h"
 #include "../crypto/mech.h"
 
@@ -243,6 +243,11 @@ static int crypto_hash_gcdelete (lua_State *L)
 }
 
 
+static sint32_t vfs_read_wrap (int fd, void *ptr, size_t len)
+{
+  return vfs_read (fd, ptr, len);
+}
+
 /* rawdigest = crypto.hash("MD5", filename)
  * strdigest = crypto.toHex(rawdigest)
  */
@@ -254,17 +259,17 @@ static int crypto_flhash (lua_State *L)
   const char *filename = luaL_checkstring (L, 2);
 
   // Open the file
-  int file_fd = fs_open (filename, FS_RDONLY);
-  if(file_fd < FS_OPEN_OK) {
+  int file_fd = vfs_open (filename, "r");
+  if(!file_fd) {
     return bad_file(L);
   }
 
   // Compute hash
   uint8_t digest[mi->digest_size];
-  int returncode = crypto_fhash (mi, &fs_read, file_fd, digest);
+  int returncode = crypto_fhash (mi, &vfs_read_wrap, file_fd, digest);
 
   // Finish up
-  fs_close(file_fd);
+  vfs_close(file_fd);
 
   if (returncode == ENOMEM)
     return bad_mem (L);

+ 11 - 11
app/modules/enduser_setup.c

@@ -45,7 +45,7 @@
 #include "espconn.h"
 #include "lwip/tcp.h"
 #include "lwip/pbuf.h"
-#include "flash_fs.h"
+#include "vfs.h"
 #include "task/task.h"
 
 #define MIN(x, y)  (((x) < (y)) ? (x) : (y))
@@ -485,20 +485,20 @@ static int enduser_setup_http_load_payload(void)
 {
   ENDUSER_SETUP_DEBUG("enduser_setup_http_load_payload");
 
-  int err = (FS_OPEN_OK -1);
-  int err2 = (FS_OPEN_OK -1);
+  int err = VFS_RES_ERR;
+  int err2 = VFS_RES_ERR;
   int file_len = 0;
-  int f = fs_open(http_html_filename, fs_mode2flag("r"));
-  if (f >= FS_OPEN_OK) {
-      err = fs_seek(f, 0, FS_SEEK_END);
-      file_len = (int) fs_tell(f);
-      err2 = fs_seek(f, 0, FS_SEEK_SET);
+  int f = vfs_open(http_html_filename, "r");
+  if (f) {
+      err = vfs_lseek(f, 0, VFS_SEEK_END);
+      file_len = (int) vfs_tell(f);
+      err2 = vfs_lseek(f, 0, VFS_SEEK_SET);
   }
 
   const char cl_hdr[] = "Content-length:%5d\r\n\r\n";
   const size_t cl_len = LITLEN(cl_hdr) + 3; /* room to expand %4d */
 
-  if (f < FS_OPEN_OK || err < FS_OPEN_OK || err2 < FS_OPEN_OK)
+  if (!f || err != VFS_RES_OK || err2 != VFS_RES_OK)
   {
     ENDUSER_SETUP_DEBUG("enduser_setup_http_load_payload unable to load file enduser_setup.html, loading backup HTML.");
 
@@ -531,8 +531,8 @@ static int enduser_setup_http_load_payload(void)
   c_memcpy(&(state->http_payload_data[offset]), &(http_header_200), LITLEN(http_header_200));
   offset += LITLEN(http_header_200);
   offset += c_sprintf(state->http_payload_data + offset, cl_hdr, file_len);
-  fs_read(f, &(state->http_payload_data[offset]), file_len);
-  fs_close(f);
+  vfs_read(f, &(state->http_payload_data[offset]), file_len);
+  vfs_close(f);
 
   return 0;
 }

+ 240 - 102
app/modules/file.c

@@ -5,42 +5,95 @@
 #include "platform.h"
 
 #include "c_types.h"
-#include "flash_fs.h"
+#include "vfs.h"
 #include "c_string.h"
 
-static volatile int file_fd = FS_OPEN_OK - 1;
+static int file_fd = 0;
+static int rtc_cb_ref = LUA_NOREF;
 
-// Lua: open(filename, mode)
-static int file_open( lua_State* L )
+
+static void table2tm( lua_State *L, vfs_time *tm )
 {
-  size_t len;
-  if((FS_OPEN_OK - 1)!=file_fd){
-    fs_close(file_fd);
-    file_fd = FS_OPEN_OK - 1;
-  }
+  int idx = lua_gettop( L );
+
+  // extract items from table
+  lua_getfield( L, idx, "year" );
+  lua_getfield( L, idx, "mon" );
+  lua_getfield( L, idx, "day" );
+  lua_getfield( L, idx, "hour" );
+  lua_getfield( L, idx, "min" );
+  lua_getfield( L, idx, "sec" );
+
+  tm->year = luaL_optint( L, ++idx, 2016 );
+  tm->mon  = luaL_optint( L, ++idx, 6 );
+  tm->day  = luaL_optint( L, ++idx, 21 );
+  tm->hour = luaL_optint( L, ++idx, 0 );
+  tm->min  = luaL_optint( L, ++idx, 0 );
+  tm->sec  = luaL_optint( L, ++idx, 0 );
+
+  // remove items from stack
+  lua_pop( L, 6 );
+}
 
-  const char *fname = luaL_checklstring( L, 1, &len );
-  luaL_argcheck(L, len < FS_NAME_MAX_LENGTH && c_strlen(fname) == len, 1, "filename invalid");
+static sint32_t file_rtc_cb( vfs_time *tm )
+{
+  sint32_t res = VFS_RES_ERR;
 
-  const char *mode = luaL_optstring(L, 2, "r");
+  if (rtc_cb_ref != LUA_NOREF) {
+    lua_State *L = lua_getstate();
 
-  file_fd = fs_open(fname, fs_mode2flag(mode));
+    lua_rawgeti( L, LUA_REGISTRYINDEX, rtc_cb_ref );
+    lua_call( L, 0, 1 );
 
-  if(file_fd < FS_OPEN_OK){
-    file_fd = FS_OPEN_OK - 1;
-    lua_pushnil(L);
-  } else {
-    lua_pushboolean(L, 1);
+    if (lua_type( L, lua_gettop( L ) ) == LUA_TTABLE) {
+      table2tm( L, tm );
+      res = VFS_RES_OK;
+    }
+
+    // pop item returned by callback
+    lua_pop( L, 1 );
   }
-  return 1; 
+
+  return res;
+}
+
+// Lua: on()
+static int file_on(lua_State *L)
+{
+  enum events{
+    ON_RTC = 0
+  };
+  const char *const eventnames[] = {"rtc", NULL};
+
+  int event = luaL_checkoption(L, 1, "rtc", eventnames);
+
+  switch (event) {
+  case ON_RTC:
+    luaL_unref(L, LUA_REGISTRYINDEX, rtc_cb_ref);
+
+    if ((lua_type(L, 2) == LUA_TFUNCTION) ||
+        (lua_type(L, 2) == LUA_TLIGHTFUNCTION)) {
+      lua_pushvalue(L, 2);  // copy argument (func) to the top of stack
+      rtc_cb_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+      vfs_register_rtc_cb(file_rtc_cb);
+    } else {
+      rtc_cb_ref = LUA_NOREF;
+      vfs_register_rtc_cb(NULL);
+    }
+    break;
+  default:
+    break;
+  }
+
+  return 0;
 }
 
 // Lua: close()
 static int file_close( lua_State* L )
 {
-  if((FS_OPEN_OK - 1)!=file_fd){
-    fs_close(file_fd);
-    file_fd = FS_OPEN_OK - 1;
+  if(file_fd){
+    vfs_close(file_fd);
+    file_fd = 0;
   }
   return 0;  
 }
@@ -50,7 +103,7 @@ static int file_format( lua_State* L )
 {
   size_t len;
   file_close(L);
-  if( !fs_format() )
+  if( !vfs_format() )
   {
     NODE_ERR( "\n*** ERROR ***: unable to format. FS might be compromised.\n" );
     NODE_ERR( "It is advised to re-flash the NodeMCU image.\n" );
@@ -59,44 +112,77 @@ static int file_format( lua_State* L )
   else{
     NODE_ERR( "format done.\n" );
   }
-  return 0; 
+  return 0;
 }
 
-#if defined(BUILD_SPIFFS)
+static int file_fscfg (lua_State *L)
+{
+  uint32_t phys_addr, phys_size;
+
+  vfs_fscfg("/FLASH", &phys_addr, &phys_size);
 
-extern spiffs fs;
+  lua_pushinteger (L, phys_addr);
+  lua_pushinteger (L, phys_size);
+  return 2;
+}
+
+// Lua: open(filename, mode)
+static int file_open( lua_State* L )
+{
+  size_t len;
+  if(file_fd){
+    vfs_close(file_fd);
+    file_fd = 0;
+  }
+
+  const char *fname = luaL_checklstring( L, 1, &len );
+  const char *basename = vfs_basename( fname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(fname) == len, 1, "filename invalid");
+
+  const char *mode = luaL_optstring(L, 2, "r");
+
+  file_fd = vfs_open(fname, mode);
+
+  if(!file_fd){
+    lua_pushnil(L);
+  } else {
+    lua_pushboolean(L, 1);
+  }
+  return 1; 
+}
 
 // Lua: list()
 static int file_list( lua_State* L )
 {
-  spiffs_DIR d;
-  struct spiffs_dirent e;
-  struct spiffs_dirent *pe = &e;
-
-  lua_newtable( L );
-  SPIFFS_opendir(&fs, "/", &d);
-  while ((pe = SPIFFS_readdir(&d, pe))) {
-    // NODE_ERR("  %s size:%i\n", pe->name, pe->size);
-    lua_pushinteger(L, pe->size);
-    lua_setfield( L, -2, pe->name );
+  vfs_dir  *dir;
+  vfs_item *item;
+
+  if (dir = vfs_opendir("")) {
+    lua_newtable( L );
+    while (item = vfs_readdir(dir)) {
+      lua_pushinteger(L, vfs_item_size(item));
+      lua_setfield(L, -2, vfs_item_name(item));
+      vfs_closeitem(item);
+    }
+    vfs_closedir(dir);
+    return 1;
   }
-  SPIFFS_closedir(&d);
-  return 1;
+  return 0;
 }
 
 static int file_seek (lua_State *L) 
 {
-  static const int mode[] = {FS_SEEK_SET, FS_SEEK_CUR, FS_SEEK_END};
+  static const int mode[] = {VFS_SEEK_SET, VFS_SEEK_CUR, VFS_SEEK_END};
   static const char *const modenames[] = {"set", "cur", "end", NULL};
-  if((FS_OPEN_OK - 1)==file_fd)
+  if(!file_fd)
     return luaL_error(L, "open a file first");
   int op = luaL_checkoption(L, 1, "cur", modenames);
   long offset = luaL_optlong(L, 2, 0);
-  op = fs_seek(file_fd, offset, mode[op]);
+  op = vfs_lseek(file_fd, offset, mode[op]);
   if (op < 0)
     lua_pushnil(L);  /* error */
   else
-    lua_pushinteger(L, fs_tell(file_fd));
+    lua_pushinteger(L, vfs_tell(file_fd));
   return 1;
 }
 
@@ -105,12 +191,14 @@ static int file_exists( lua_State* L )
 {
   size_t len;
   const char *fname = luaL_checklstring( L, 1, &len );    
-  luaL_argcheck(L, len < FS_NAME_MAX_LENGTH && c_strlen(fname) == len, 1, "filename invalid");
+  const char *basename = vfs_basename( fname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(fname) == len, 1, "filename invalid");
 
-  spiffs_stat stat;
-  int rc = SPIFFS_stat(&fs, (char *)fname, &stat);
+  vfs_item *stat = vfs_stat((char *)fname);
 
-  lua_pushboolean(L, (rc == SPIFFS_OK ? 1 : 0));
+  lua_pushboolean(L, stat ? 1 : 0);
+
+  if (stat) vfs_closeitem(stat);
 
   return 1;
 }
@@ -120,49 +208,43 @@ static int file_remove( lua_State* L )
 {
   size_t len;
   const char *fname = luaL_checklstring( L, 1, &len );    
-  luaL_argcheck(L, len < FS_NAME_MAX_LENGTH && c_strlen(fname) == len, 1, "filename invalid");
+  const char *basename = vfs_basename( fname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(fname) == len, 1, "filename invalid");
   file_close(L);
-  SPIFFS_remove(&fs, (char *)fname);
-  return 0;  
+  vfs_remove((char *)fname);
+  return 0;
 }
 
 // Lua: flush()
 static int file_flush( lua_State* L )
 {
-  if((FS_OPEN_OK - 1)==file_fd)
+  if(!file_fd)
     return luaL_error(L, "open a file first");
-  if(fs_flush(file_fd) == 0)
+  if(vfs_flush(file_fd) == 0)
     lua_pushboolean(L, 1);
   else
     lua_pushnil(L);
   return 1;
 }
-#if 0
-// Lua: check()
-static int file_check( lua_State* L )
-{
-  file_close(L);
-  lua_pushinteger(L, fs_check());
-  return 1;
-}
-#endif
 
 // Lua: rename("oldname", "newname")
 static int file_rename( lua_State* L )
 {
   size_t len;
-  if((FS_OPEN_OK - 1)!=file_fd){
-    fs_close(file_fd);
-    file_fd = FS_OPEN_OK - 1;
+  if(file_fd){
+    vfs_close(file_fd);
+    file_fd = 0;
   }
 
   const char *oldname = luaL_checklstring( L, 1, &len );
-  luaL_argcheck(L, len < FS_NAME_MAX_LENGTH && c_strlen(oldname) == len, 1, "filename invalid");
+  const char *basename = vfs_basename( oldname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(oldname) == len, 1, "filename invalid");
   
   const char *newname = luaL_checklstring( L, 2, &len );  
-  luaL_argcheck(L, len < FS_NAME_MAX_LENGTH && c_strlen(newname) == len, 2, "filename invalid");
+  basename = vfs_basename( newname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(newname) == len, 2, "filename invalid");
 
-  if(SPIFFS_OK==myspiffs_rename( oldname, newname )){
+  if(0 <= vfs_rename( oldname, newname )){
     lua_pushboolean(L, 1);
   } else {
     lua_pushboolean(L, 0);
@@ -170,26 +252,6 @@ static int file_rename( lua_State* L )
   return 1;
 }
 
-// Lua: fsinfo()
-static int file_fsinfo( lua_State* L )
-{
-  u32_t total, used;
-  if (SPIFFS_info(&fs, &total, &used)) {
-    return luaL_error(L, "file system failed");
-  }
-  NODE_DBG("total: %d, used:%d\n", total, used);
-  if(total>0x7FFFFFFF || used>0x7FFFFFFF || used > total)
-  {
-    return luaL_error(L, "file system error");
-  }
-  lua_pushinteger(L, total-used);
-  lua_pushinteger(L, used);
-  lua_pushinteger(L, total);
-  return 3;
-}
-
-#endif
-
 // g_read()
 static int file_g_read( lua_State* L, int n, int16_t end_char )
 {
@@ -199,14 +261,14 @@ static int file_g_read( lua_State* L, int n, int16_t end_char )
     end_char = EOF;
   
   luaL_Buffer b;
-  if((FS_OPEN_OK - 1)==file_fd)
+  if(!file_fd)
     return luaL_error(L, "open a file first");
 
   luaL_buffinit(L, &b);
   char *p = luaL_prepbuffer(&b);
   int i;
 
-  n = fs_read(file_fd, p, n);
+  n = vfs_read(file_fd, p, n);
   for (i = 0; i < n; ++i)
     if (p[i] == end_char)
     {
@@ -219,7 +281,7 @@ static int file_g_read( lua_State* L, int n, int16_t end_char )
     return (lua_objlen(L, -1) > 0);  /* check whether read something */
   }
 
-  fs_seek(file_fd, -(n - i), SEEK_CUR);
+  vfs_lseek(file_fd, -(n - i), VFS_SEEK_CUR);
   luaL_addsize(&b, i);
   luaL_pushresult(&b);  /* close buffer */
   return 1;  /* read at least an `eol' */ 
@@ -262,11 +324,11 @@ static int file_readline( lua_State* L )
 // Lua: write("string")
 static int file_write( lua_State* L )
 {
-  if((FS_OPEN_OK - 1)==file_fd)
+  if(!file_fd)
     return luaL_error(L, "open a file first");
   size_t l, rl;
   const char *s = luaL_checklstring(L, 1, &l);
-  rl = fs_write(file_fd, s, l);
+  rl = vfs_write(file_fd, s, l);
   if(rl==l)
     lua_pushboolean(L, 1);
   else
@@ -277,13 +339,13 @@ static int file_write( lua_State* L )
 // Lua: writeline("string")
 static int file_writeline( lua_State* L )
 {
-  if((FS_OPEN_OK - 1)==file_fd)
+  if(!file_fd)
     return luaL_error(L, "open a file first");
   size_t l, rl;
   const char *s = luaL_checklstring(L, 1, &l);
-  rl = fs_write(file_fd, s, l);
+  rl = vfs_write(file_fd, s, l);
   if(rl==l){
-    rl = fs_write(file_fd, "\n", 1);
+    rl = vfs_write(file_fd, "\n", 1);
     if(rl==1)
       lua_pushboolean(L, 1);
     else
@@ -295,13 +357,79 @@ static int file_writeline( lua_State* L )
   return 1;
 }
 
-static int file_fscfg (lua_State *L)
+// Lua: fsinfo()
+static int file_fsinfo( lua_State* L )
 {
-  lua_pushinteger (L, fs.cfg.phys_addr);
-  lua_pushinteger (L, fs.cfg.phys_size);
-  return 2;
+  u32_t total, used;
+  if (vfs_fsinfo("", &total, &used)) {
+    return luaL_error(L, "file system failed");
+  }
+  NODE_DBG("total: %d, used:%d\n", total, used);
+  if(total>0x7FFFFFFF || used>0x7FFFFFFF || used > total)
+  {
+    return luaL_error(L, "file system error");
+  }
+  lua_pushinteger(L, total-used);
+  lua_pushinteger(L, used);
+  lua_pushinteger(L, total);
+  return 3;
 }
 
+typedef struct {
+  vfs_vol *vol;
+} volume_type;
+
+// Lua: vol = file.mount("/SD0")
+static int file_mount( lua_State *L )
+{
+  const char *ldrv = luaL_checkstring( L, 1 );
+  int num = luaL_optint( L, 2, -1 );
+  volume_type *vol = (volume_type *)lua_newuserdata( L, sizeof( volume_type ) );
+
+  if (vol->vol = vfs_mount( ldrv, num )) {
+    /* set its metatable */
+    luaL_getmetatable(L, "vfs.vol");
+    lua_setmetatable(L, -2);
+    return 1;
+  } else {
+    // remove created userdata
+    lua_pop( L, 1 );
+    return 0;
+  }
+}
+
+// Lua: success = file.chdir("/SD0/")
+static int file_chdir( lua_State *L )
+{
+  const char *path = luaL_checkstring( L, 1 );
+
+  lua_pushboolean( L, 0 <= vfs_chdir( path ) );
+  return 1;
+}
+
+static int file_vol_umount( lua_State *L )
+{
+  volume_type *vol = luaL_checkudata( L, 1, "file.vol" );
+  luaL_argcheck( L, vol, 1, "volume expected" );
+
+  lua_pushboolean( L, 0 <= vfs_umount( vol->vol ) );
+
+  // invalidate vfs descriptor, it has been free'd anyway
+  vol->vol = NULL;
+  return 1;
+}
+
+
+static const LUA_REG_TYPE file_vol_map[] =
+{
+  { LSTRKEY( "umount" ),   LFUNCVAL( file_vol_umount )},
+  //{ LSTRKEY( "getfree" ),  LFUNCVAL( file_vol_getfree )},
+  //{ LSTRKEY( "getlabel" ), LFUNCVAL( file_vol_getlabel )},
+  //{ LSTRKEY( "__gc" ),     LFUNCVAL( file_vol_free ) },
+  { LSTRKEY( "__index" ),  LROVAL( file_vol_map ) },
+  { LNILKEY, LNILVAL }
+};
+
 // Module function map
 static const LUA_REG_TYPE file_map[] = {
   { LSTRKEY( "list" ),      LFUNCVAL( file_list ) },
@@ -311,17 +439,27 @@ static const LUA_REG_TYPE file_map[] = {
   { LSTRKEY( "writeline" ), LFUNCVAL( file_writeline ) },
   { LSTRKEY( "read" ),      LFUNCVAL( file_read ) },
   { LSTRKEY( "readline" ),  LFUNCVAL( file_readline ) },
+#ifdef BUILD_SPIFFS
   { LSTRKEY( "format" ),    LFUNCVAL( file_format ) },
-#if defined(BUILD_SPIFFS)
+  { LSTRKEY( "fscfg" ),     LFUNCVAL( file_fscfg ) },
+#endif
   { LSTRKEY( "remove" ),    LFUNCVAL( file_remove ) },
   { LSTRKEY( "seek" ),      LFUNCVAL( file_seek ) },
   { LSTRKEY( "flush" ),     LFUNCVAL( file_flush ) },
   { LSTRKEY( "rename" ),    LFUNCVAL( file_rename ) },
-  { LSTRKEY( "fsinfo" ),    LFUNCVAL( file_fsinfo ) },
-  { LSTRKEY( "fscfg" ),     LFUNCVAL( file_fscfg ) },
   { LSTRKEY( "exists" ),    LFUNCVAL( file_exists ) },  
+  { LSTRKEY( "fsinfo" ),    LFUNCVAL( file_fsinfo ) },
+  { LSTRKEY( "on" ),        LFUNCVAL( file_on ) },
+#ifdef BUILD_FATFS
+  { LSTRKEY( "mount" ),     LFUNCVAL( file_mount ) },
+  { LSTRKEY( "chdir" ),     LFUNCVAL( file_chdir ) },
 #endif
   { LNILKEY, LNILVAL }
 };
 
-NODEMCU_MODULE(FILE, "file", file_map, NULL);
+int luaopen_file( lua_State *L ) {
+  luaL_rometatable( L, "file.vol",  (void *)file_vol_map );
+  return 0;
+}
+
+NODEMCU_MODULE(FILE, "file", file_map, luaopen_file);

+ 18 - 13
app/modules/node.c

@@ -23,7 +23,7 @@
 #include "driver/uart.h"
 #include "user_interface.h"
 #include "flash_api.h"
-#include "flash_fs.h"
+#include "vfs.h"
 #include "user_version.h"
 #include "rom.h"
 #include "task/task.h"
@@ -226,11 +226,11 @@ static int writer(lua_State* L, const void* p, size_t size, void* u)
 {
   UNUSED(L);
   int file_fd = *( (int *)u );
-  if ((FS_OPEN_OK - 1) == file_fd)
+  if (!file_fd)
     return 1;
   NODE_DBG("get fd:%d,size:%d\n", file_fd, size);
 
-  if (size != 0 && (size != fs_write(file_fd, (const char *)p, size)) )
+  if (size != 0 && (size != vfs_write(file_fd, (const char *)p, size)) )
     return 1;
   NODE_DBG("write fd:%d,size:%d\n", file_fd, size);
   return 0;
@@ -241,23 +241,26 @@ static int writer(lua_State* L, const void* p, size_t size, void* u)
 static int node_compile( lua_State* L )
 {
   Proto* f;
-  int file_fd = FS_OPEN_OK - 1;
+  int file_fd = 0;
   size_t len;
   const char *fname = luaL_checklstring( L, 1, &len );
-  if ( len >= FS_NAME_MAX_LENGTH )
-    return luaL_error(L, "filename too long");
+  const char *basename = vfs_basename( fname );
+  luaL_argcheck(L, c_strlen(basename) <= FS_OBJ_NAME_LEN && c_strlen(fname) == len, 1, "filename invalid");
 
-  char output[FS_NAME_MAX_LENGTH];
+  char *output = luaM_malloc( L, len+1 );
   c_strcpy(output, fname);
   // check here that filename end with ".lua".
-  if (len < 4 || (c_strcmp( output + len - 4, ".lua") != 0) )
+  if (len < 4 || (c_strcmp( output + len - 4, ".lua") != 0) ) {
+    luaM_free( L, output );
     return luaL_error(L, "not a .lua file");
+  }
 
   output[c_strlen(output) - 2] = 'c';
   output[c_strlen(output) - 1] = '\0';
   NODE_DBG(output);
   NODE_DBG("\n");
   if (luaL_loadfsfile(L, fname) != 0) {
+    luaM_free( L, output );
     return luaL_error(L, lua_tostring(L, -1));
   }
 
@@ -265,9 +268,10 @@ static int node_compile( lua_State* L )
 
   int stripping = 1;      /* strip debug information? */
 
-  file_fd = fs_open(output, fs_mode2flag("w+"));
-  if (file_fd < FS_OPEN_OK)
+  file_fd = vfs_open(output, "w+");
+  if (!file_fd)
   {
+    luaM_free( L, output );
     return luaL_error(L, "cannot open/write to file");
   }
 
@@ -275,12 +279,13 @@ static int node_compile( lua_State* L )
   int result = luaU_dump(L, f, writer, &file_fd, stripping);
   lua_unlock(L);
 
-  if (fs_flush(file_fd) < 0) {   // result codes aren't propagated by flash_fs.h
+  if (vfs_flush(file_fd) != VFS_RES_OK) {
     // overwrite Lua error, like writer() does in case of a file io error
     result = 1;
   }
-  fs_close(file_fd);
-  file_fd = FS_OPEN_OK - 1;
+  vfs_close(file_fd);
+  file_fd = 0;
+  luaM_free( L, output );
 
   if (result == LUA_ERR_CC_INTOVERFLOW) {
     return luaL_error(L, "value too big or small for target integer type");

+ 0 - 28
app/platform/flash_fs.c

@@ -1,28 +0,0 @@
-#include "flash_fs.h"
-#include "c_string.h"
-
-#include "spiffs.h"
-
-int fs_mode2flag(const char *mode){
-  if(c_strlen(mode)==1){
-  	if(c_strcmp(mode,"w")==0)
-  	  return FS_WRONLY|FS_CREAT|FS_TRUNC;
-  	else if(c_strcmp(mode, "r")==0)
-  	  return FS_RDONLY;
-  	else if(c_strcmp(mode, "a")==0)
-  	  return FS_WRONLY|FS_CREAT|FS_APPEND;
-  	else
-  	  return FS_RDONLY;
-  } else if (c_strlen(mode)==2){
-  	if(c_strcmp(mode,"r+")==0)
-  	  return FS_RDWR;
-  	else if(c_strcmp(mode, "w+")==0)
-  	  return FS_RDWR|FS_CREAT|FS_TRUNC;
-  	else if(c_strcmp(mode, "a+")==0)
-  	  return FS_RDWR|FS_CREAT|FS_APPEND;
-  	else
-  	  return FS_RDONLY;
-  } else {
-  	return FS_RDONLY;
-  }
-}

+ 0 - 52
app/platform/flash_fs.h

@@ -1,52 +0,0 @@
-
-#ifndef __FLASH_FS_H__
-#define __FLASH_FS_H__
-
-#include "user_config.h"
-
-#if defined( BUILD_SPIFFS )
-
-#include "myspiffs.h"
-
-#define FS_OPEN_OK	1
-
-#define FS_RDONLY SPIFFS_RDONLY
-#define FS_WRONLY SPIFFS_WRONLY
-#define FS_RDWR SPIFFS_RDWR
-#define FS_APPEND SPIFFS_APPEND
-#define FS_TRUNC SPIFFS_TRUNC
-#define FS_CREAT SPIFFS_CREAT
-#define FS_EXCL SPIFFS_EXCL
-
-#define FS_SEEK_SET SPIFFS_SEEK_SET
-#define FS_SEEK_CUR SPIFFS_SEEK_CUR
-#define FS_SEEK_END SPIFFS_SEEK_END
-
-#define fs_open myspiffs_open
-#define fs_close myspiffs_close
-#define fs_write myspiffs_write
-#define fs_read myspiffs_read
-#define fs_seek myspiffs_lseek
-#define fs_eof myspiffs_eof
-#define fs_getc myspiffs_getc
-#define fs_ungetc myspiffs_ungetc
-#define fs_flush myspiffs_flush
-#define fs_error myspiffs_error
-#define fs_clearerr myspiffs_clearerr
-#define fs_tell myspiffs_tell
-
-#define fs_format myspiffs_format
-#define fs_check myspiffs_check
-#define fs_rename myspiffs_rename
-#define fs_size myspiffs_size
-
-#define fs_mount myspiffs_mount
-#define fs_unmount myspiffs_unmount
-
-#define FS_NAME_MAX_LENGTH SPIFFS_OBJ_NAME_LEN
-
-#endif
-
-int fs_mode2flag(const char *mode);
-
-#endif // #ifndef __FLASH_FS_H__

+ 44 - 1
app/platform/platform.c

@@ -671,7 +671,7 @@ int platform_i2c_recv_byte( unsigned id, int ack ){
 
 // *****************************************************************************
 // SPI platform interface
-uint32_t platform_spi_setup( uint8_t id, int mode, unsigned cpol, unsigned cpha, uint32_t clock_div)
+uint32_t platform_spi_setup( uint8_t id, int mode, unsigned cpol, unsigned cpha, uint32_t clock_div )
 {
   spi_master_init( id, cpol, cpha, clock_div );
   return 1;
@@ -696,6 +696,49 @@ spi_data_type platform_spi_send_recv( uint8_t id, uint8_t bitlen, spi_data_type
   return spi_mast_get_miso( id, 0, bitlen );
 }
 
+int platform_spi_blkwrite( uint8_t id, size_t len, const uint8_t *data )
+{
+  spi_mast_byte_order( id, SPI_ORDER_LSB );
+
+  while (len > 0) {
+    size_t chunk_len = len > 64 ? 64 : len;
+
+    spi_mast_blkset( id, chunk_len * 8, data );
+    spi_mast_transaction( id, 0, 0, 0, 0, chunk_len * 8, 0, 0 );
+
+    data = &(data[chunk_len]);
+    len -= chunk_len;
+  }
+
+  spi_mast_byte_order( id, SPI_ORDER_MSB );
+
+  return PLATFORM_OK;
+}
+
+int platform_spi_blkread( uint8_t id, size_t len, uint8_t *data )
+{
+  uint8_t mosi_idle[64];
+
+  os_memset( (void *)mosi_idle, 0xff, len > 64 ? 64 : len );
+
+  spi_mast_byte_order( id, SPI_ORDER_LSB );
+
+  while (len > 0 ) {
+    size_t chunk_len = len > 64 ? 64 : len;
+
+    spi_mast_blkset( id, chunk_len * 8, mosi_idle );
+    spi_mast_transaction( id, 0, 0, 0, 0, chunk_len * 8, 0, -1 );
+    spi_mast_blkget( id, chunk_len * 8, data );
+
+    data = &(data[chunk_len]);
+    len -= chunk_len;
+  }
+
+  spi_mast_byte_order( id, SPI_ORDER_MSB );
+
+  return PLATFORM_OK;
+}
+
 int platform_spi_set_mosi( uint8_t id, uint16_t offset, uint8_t bitlen, spi_data_type data )
 {
   if (offset + bitlen > 512)

+ 2 - 0
app/platform/platform.h

@@ -110,6 +110,8 @@ int platform_spi_send( uint8_t id, uint8_t bitlen, spi_data_type data );
 spi_data_type platform_spi_send_recv( uint8_t id, uint8_t bitlen, spi_data_type data );
 void platform_spi_select( unsigned id, int is_select );
 
+int platform_spi_blkwrite( uint8_t id, size_t len, const uint8_t *data );
+int platform_spi_blkread( uint8_t id, size_t len, uint8_t *data );
 int platform_spi_set_mosi( uint8_t id, uint16_t offset, uint8_t bitlen, spi_data_type data );
 spi_data_type platform_spi_get_miso( uint8_t id, uint16_t offset, uint8_t bitlen );
 int platform_spi_transaction( uint8_t id, uint8_t cmd_bitlen, spi_data_type cmd_data,

+ 563 - 0
app/platform/sdcard.c

@@ -0,0 +1,563 @@
+
+#include "platform.h"
+#include "driver/spi.h"
+#include "c_types.h"
+
+#include "sdcard.h"
+
+
+#define CHECK_SSPIN(pin) \
+  if (pin < 1 || pin > NUM_GPIO) return FALSE; \
+  m_ss_pin = pin;
+
+
+//==============================================================================
+// SD card commands
+/** GO_IDLE_STATE - init card in spi mode if CS low */
+uint8_t const CMD0 = 0X00;
+/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
+uint8_t const CMD8 = 0X08;
+/** SEND_CSD - read the Card Specific Data (CSD register) */
+uint8_t const CMD9 = 0X09;
+/** SEND_CID - read the card identification information (CID register) */
+uint8_t const CMD10 = 0X0A;
+/** STOP_TRANSMISSION - end multiple block read sequence */
+uint8_t const CMD12 = 0X0C;
+/** SEND_STATUS - read the card status register */
+uint8_t const CMD13 = 0X0D;
+/** READ_SINGLE_BLOCK - read a single data block from the card */
+uint8_t const CMD17 = 0X11;
+/** READ_MULTIPLE_BLOCK - read a multiple data blocks from the card */
+uint8_t const CMD18 = 0X12;
+/** WRITE_BLOCK - write a single data block to the card */
+uint8_t const CMD24 = 0X18;
+/** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
+uint8_t const CMD25 = 0X19;
+/** ERASE_WR_BLK_START - sets the address of the first block to be erased */
+uint8_t const CMD32 = 0X20;
+/** ERASE_WR_BLK_END - sets the address of the last block of the continuous
+    range to be erased*/
+uint8_t const CMD33 = 0X21;
+/** ERASE - erase all previously selected blocks */
+uint8_t const CMD38 = 0X26;
+/** APP_CMD - escape for application specific command */
+uint8_t const CMD55 = 0X37;
+/** READ_OCR - read the OCR register of a card */
+uint8_t const CMD58 = 0X3A;
+/** CRC_ON_OFF - enable or disable CRC checking */
+uint8_t const CMD59 = 0X3B;
+/** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
+     pre-erased before writing */
+uint8_t const ACMD23 = 0X17;
+/** SD_SEND_OP_COMD - Sends host capacity support information and
+    activates the card's initialization process */
+uint8_t const ACMD41 = 0X29;
+//==============================================================================
+/** status for card in the ready state */
+uint8_t const R1_READY_STATE = 0X00;
+/** status for card in the idle state */
+uint8_t const R1_IDLE_STATE = 0X01;
+/** status bit for illegal command */
+uint8_t const R1_ILLEGAL_COMMAND = 0X04;
+/** start data token for read or write single block*/
+uint8_t const DATA_START_BLOCK = 0XFE;
+/** stop token for write multiple blocks*/
+uint8_t const STOP_TRAN_TOKEN = 0XFD;
+/** start data token for write multiple blocks*/
+uint8_t const WRITE_MULTIPLE_TOKEN = 0XFC;
+/** mask for data response tokens after a write block operation */
+uint8_t const DATA_RES_MASK = 0X1F;
+/** write data accepted token */
+uint8_t const DATA_RES_ACCEPTED = 0X05;
+
+//------------------------------------------------------------------------------
+// SD card errors
+/** timeout error for command CMD0 (initialize card in SPI mode) */
+uint8_t const SD_CARD_ERROR_CMD0 = 0X1;
+/** CMD8 was not accepted - not a valid SD card*/
+uint8_t const SD_CARD_ERROR_CMD8 = 0X2;
+/** card returned an error response for CMD12 (stop multiblock read) */
+uint8_t const SD_CARD_ERROR_CMD12 = 0X3;
+/** card returned an error response for CMD17 (read block) */
+uint8_t const SD_CARD_ERROR_CMD17 = 0X4;
+/** card returned an error response for CMD18 (read multiple block) */
+uint8_t const SD_CARD_ERROR_CMD18 = 0X5;
+/** card returned an error response for CMD24 (write block) */
+uint8_t const SD_CARD_ERROR_CMD24 = 0X6;
+/**  WRITE_MULTIPLE_BLOCKS command failed */
+uint8_t const SD_CARD_ERROR_CMD25 = 0X7;
+/** card returned an error response for CMD58 (read OCR) */
+uint8_t const SD_CARD_ERROR_CMD58 = 0X8;
+/** SET_WR_BLK_ERASE_COUNT failed */
+uint8_t const SD_CARD_ERROR_ACMD23 = 0X9;
+/** ACMD41 initialization process timeout */
+uint8_t const SD_CARD_ERROR_ACMD41 = 0XA;
+/** card returned a bad CSR version field */
+uint8_t const SD_CARD_ERROR_BAD_CSD = 0XB;
+/** erase block group command failed */
+uint8_t const SD_CARD_ERROR_ERASE = 0XC;
+/** card not capable of single block erase */
+uint8_t const SD_CARD_ERROR_ERASE_SINGLE_BLOCK = 0XD;
+/** Erase sequence timed out */
+uint8_t const SD_CARD_ERROR_ERASE_TIMEOUT = 0XE;
+/** card returned an error token instead of read data */
+uint8_t const SD_CARD_ERROR_READ = 0XF;
+/** read CID or CSD failed */
+uint8_t const SD_CARD_ERROR_READ_REG = 0X10;
+/** timeout while waiting for start of read data */
+uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X11;
+/** card did not accept STOP_TRAN_TOKEN */
+uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X12;
+/** card returned an error token as a response to a write operation */
+uint8_t const SD_CARD_ERROR_WRITE = 0X13;
+/** attempt to write protected block zero */
+uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X14;  // REMOVE - not used
+/** card did not go ready for a multiple block write */
+uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X15;
+/** card returned an error to a CMD13 status check after a write */
+uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X16;
+/** timeout occurred during write programming */
+uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X17;
+/** incorrect rate selected */
+uint8_t const SD_CARD_ERROR_SCK_RATE = 0X18;
+/** init() not called */
+uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0X19;
+/** card returned an error for CMD59 (CRC_ON_OFF) */
+uint8_t const SD_CARD_ERROR_CMD59 = 0X1A;
+/** invalid read CRC */
+uint8_t const SD_CARD_ERROR_READ_CRC = 0X1B;
+/** SPI DMA error */
+uint8_t const SD_CARD_ERROR_SPI_DMA = 0X1C;
+//------------------------------------------------------------------------------
+// card types
+uint8_t const SD_CARD_TYPE_INVALID = 0;
+/** Standard capacity V1 SD card */
+uint8_t const SD_CARD_TYPE_SD1  = 1;
+/** Standard capacity V2 SD card */
+uint8_t const SD_CARD_TYPE_SD2  = 2;
+/** High Capacity SD card */
+uint8_t const SD_CARD_TYPE_SDHC = 3;
+
+
+typedef struct {
+  uint32_t start, target;
+} to_t;
+
+static uint8_t m_spi_no, m_ss_pin, m_status, m_type, m_error;
+
+static void sdcard_chipselect_low( void ) {
+  platform_gpio_write( m_ss_pin, PLATFORM_GPIO_LOW );
+}
+
+static void sdcard_chipselect_high( void ) {
+  platform_gpio_write( m_ss_pin, PLATFORM_GPIO_HIGH );
+  // send some cc to ensure that MISO returns to high
+  platform_spi_send_recv( m_spi_no, 8, 0xff );
+}
+
+static void set_timeout( to_t *to, uint32_t us )
+{
+  uint32_t offset;
+
+  to->start = system_get_time();
+
+  offset = 0xffffffff - to->start;
+  if (offset > us) {
+    to->target = us - offset;
+  } else {
+    to->target = to->start + us;
+  }
+}
+
+static uint8_t timed_out( to_t *to )
+{
+  uint32_t now = system_get_time();
+
+  if (to->start < to->target) {
+    if ((now >= to->start) && (now <= to->target)) {
+      return FALSE;
+    } else {
+      return TRUE;
+    }
+  } else {
+    if ((now >= to->start) || (now <= to->target)) {
+      return FALSE;
+    } else {
+      return TRUE;
+    }
+  }
+}
+
+static int sdcard_wait_not_busy( uint32_t us )
+{
+  to_t to;
+
+  set_timeout( &to, us );
+  while (platform_spi_send_recv( m_spi_no, 8, 0xff ) != 0xff) {
+    if (timed_out( &to )) {
+      goto fail;
+    }
+  }
+  return TRUE;
+
+  fail:
+  return FALSE;
+}
+
+static uint8_t sdcard_command( uint8_t cmd, uint32_t arg )
+{
+  sdcard_chipselect_low();
+
+  // wait until card is busy
+  sdcard_wait_not_busy( 100 * 1000 );
+
+  // send command
+  // with precalculated CRC - correct for CMD0 with arg zero or CMD8 with arg 0x1AA
+  const uint8_t crc = cmd == CMD0 ? 0x95 : 0x87;
+  platform_spi_transaction( m_spi_no, 16, (cmd | 0x40) << 8 | arg >> 24, 32, arg << 8 | crc, 0, 0, 0 );
+
+  // skip dangling byte of data transfer
+  if (cmd == CMD12) {
+    platform_spi_transaction( m_spi_no, 8, 0xff, 0, 0, 0, 0, 0 );
+  }
+
+  // wait for response
+  for (uint8_t i = 0; ((m_status = platform_spi_send_recv( m_spi_no, 8, 0xff )) & 0x80) && i != 0xFF; i++) ;
+
+  return m_status;
+}
+
+static uint8_t sdcard_acmd( uint8_t cmd, uint32_t arg ) {
+  sdcard_command( CMD55, 0 );
+  return sdcard_command( cmd, arg );
+}
+
+static int sdcard_write_data( uint8_t token, const uint8_t *src)
+{
+  uint16_t crc = 0xffff;
+
+  platform_spi_transaction( m_spi_no, 8, token, 0, 0, 0, 0, 0 );
+  platform_spi_blkwrite( m_spi_no, 512, src );
+  platform_spi_transaction( m_spi_no, 16, crc, 0, 0, 0, 0, 0 );
+
+  m_status = platform_spi_send_recv( m_spi_no, 8, 0xff );
+  if ((m_status & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
+    m_error = SD_CARD_ERROR_WRITE;
+    goto fail;
+  }
+  return TRUE;
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+static int sdcard_read_data( uint8_t *dst, size_t count )
+{
+  to_t to;
+
+  // wait for start block token
+  set_timeout( &to, 100 * 1000 );
+  while ((m_status = platform_spi_send_recv( m_spi_no, 8, 0xff)) == 0xff) {
+    if (timed_out( &to )) {
+      goto fail;
+    }
+  }
+
+  if (m_status != DATA_START_BLOCK) {
+    m_error = SD_CARD_ERROR_READ;
+    goto fail;
+  }
+  // transfer data
+  platform_spi_blkread( m_spi_no, count, (void *)dst );
+
+  // discard crc
+  platform_spi_transaction( m_spi_no, 16, 0xffff, 0, 0, 0, 0, 0 );
+
+  sdcard_chipselect_high();
+  return TRUE;
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+static int sdcard_read_register( uint8_t cmd, uint8_t *buf )
+{
+  if (sdcard_command( cmd, 0 )) {
+    m_error = SD_CARD_ERROR_READ_REG;
+    goto fail;
+  }
+  return sdcard_read_data( buf, 16 );
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+int platform_sdcard_init( uint8_t spi_no, uint8_t ss_pin )
+{
+  uint32_t arg, user_spi_clkdiv;
+  to_t to;
+
+  m_type = SD_CARD_TYPE_INVALID;
+  m_error = 0;
+
+  if (spi_no > 1) {
+    return FALSE;
+  }
+  m_spi_no = spi_no;
+  CHECK_SSPIN(ss_pin);
+
+  platform_gpio_write( m_ss_pin, PLATFORM_GPIO_HIGH );
+  platform_gpio_mode( m_ss_pin, PLATFORM_GPIO_OUTPUT, PLATFORM_GPIO_FLOAT );
+
+  // set SPI clock to 400 kHz for init phase
+  user_spi_clkdiv = spi_set_clkdiv( m_spi_no, 200 );
+
+  // apply initialization sequence:
+  // keep ss and io high, apply clock for max(1ms; 74cc)
+  // 1ms requires 400cc @ 400kHz
+  for (int i = 0; i < 2; i++) {
+    platform_spi_transaction( m_spi_no, 0, 0, 0, 0, 0, 200, 0 );
+  }
+
+  // command to go idle in SPI mode
+  set_timeout( &to, 500 * 1000 );
+  while (sdcard_command( CMD0, 0 ) != R1_IDLE_STATE) {
+    if (timed_out( &to )) {
+      goto fail;
+    }
+  }
+
+  set_timeout( &to, 500 * 1000 );
+  while (1) {
+    if (sdcard_command( CMD8, 0x1aa) == (R1_ILLEGAL_COMMAND | R1_IDLE_STATE)) {
+      m_type = SD_CARD_TYPE_SD1;
+      break;
+    }
+    for (uint8_t i = 0; i < 4; i++) {
+      m_status = platform_spi_send_recv( m_spi_no, 8, 0xff );
+    }
+    if (m_status == 0xaa) {
+      m_type = SD_CARD_TYPE_SD2;
+      break;
+    }
+    if (timed_out( &to )) {
+      goto fail;
+    }
+  }
+  // initialize card and send host supports SDHC if SD2
+  arg = m_type == SD_CARD_TYPE_SD2 ? 0x40000000 : 0;
+
+  set_timeout( &to, 500 * 1000 );
+  while (sdcard_acmd( ACMD41, arg ) != R1_READY_STATE) {
+    if (timed_out( &to )) {
+      goto fail;
+    }
+  }
+  // if SD2 read OCR register to check for SDHC card
+  if (m_type == SD_CARD_TYPE_SD2) {
+    if (sdcard_command( CMD58, 0 )) {
+      m_error = SD_CARD_ERROR_CMD58;
+      goto fail;
+    }
+    if ((platform_spi_send_recv( m_spi_no, 8, 0xff ) & 0xC0) == 0xC0) {
+      m_type = SD_CARD_TYPE_SDHC;
+    }
+    // Discard rest of ocr - contains allowed voltage range.
+    for (uint8_t i = 0; i < 3; i++) {
+      platform_spi_send_recv( m_spi_no, 8, 0xff);
+    }
+  }
+  sdcard_chipselect_high();
+
+  // re-apply user's spi clock divider
+  spi_set_clkdiv( m_spi_no, user_spi_clkdiv );
+
+  return TRUE;
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+int platform_sdcard_status( void )
+{
+  return m_status;
+}
+
+int platform_sdcard_error( void )
+{
+  return m_error;
+}
+
+int platform_sdcard_type( void )
+{
+  return m_type;
+}
+
+int platform_sdcard_read_block( uint8_t ss_pin, uint32_t block, uint8_t *dst )
+{
+  CHECK_SSPIN(ss_pin);
+
+  // generate byte address for pre-SDHC types
+  if (m_type != SD_CARD_TYPE_SDHC) {
+    block <<= 9;
+  }
+  if (sdcard_command( CMD17, block )) {
+    m_error = SD_CARD_ERROR_CMD17;
+    goto fail;
+  }
+  return sdcard_read_data( dst, 512 );
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+int platform_sdcard_read_blocks( uint8_t ss_pin, uint32_t block, size_t num, uint8_t *dst )
+{
+  CHECK_SSPIN(ss_pin);
+
+  if (num == 0) {
+    return TRUE;
+  }
+  if (num == 1) {
+    return platform_sdcard_read_block( ss_pin, block, dst );
+  }
+
+  // generate byte address for pre-SDHC types
+  if (m_type != SD_CARD_TYPE_SDHC) {
+    block <<= 9;
+  }
+
+  // command READ_MULTIPLE_BLOCKS
+  if (sdcard_command( CMD18, block )) {
+    m_error = SD_CARD_ERROR_CMD18;
+    goto fail;
+  }
+
+  // read required blocks
+  while (num > 0) {
+    sdcard_chipselect_low();
+    if (sdcard_read_data( dst, 512 )) {
+      num--;
+      dst = &(dst[512]);
+    } else {
+      break;
+    }
+  }
+
+  // issue command STOP_TRANSMISSION
+  if (sdcard_command( CMD12, 0 )) {
+    m_error = SD_CARD_ERROR_CMD12;
+    goto fail;
+  }
+  sdcard_chipselect_high();
+  return TRUE;
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+int platform_sdcard_read_csd( uint8_t ss_pin, uint8_t *csd )
+{
+  CHECK_SSPIN(ss_pin);
+
+  return sdcard_read_register( CMD9, csd );
+}
+
+int platform_sdcard_read_cid( uint8_t ss_pin, uint8_t *cid )
+{
+  CHECK_SSPIN(ss_pin);
+
+  return sdcard_read_register( CMD10, cid );
+}
+
+int platform_sdcard_write_block( uint8_t ss_pin, uint32_t block, const uint8_t *src )
+{
+  CHECK_SSPIN(ss_pin);
+
+  // generate byte address for pre-SDHC types
+  if (m_type != SD_CARD_TYPE_SDHC) {
+    block <<= 9;
+  }
+  if (sdcard_command( CMD24, block )) {
+    m_error = SD_CARD_ERROR_CMD24;
+    goto fail;
+  }
+  if (! sdcard_write_data( DATA_START_BLOCK, src )) {
+    goto fail;
+  }
+
+  sdcard_chipselect_high();
+  return TRUE;
+
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+static int sdcard_write_stop( void )
+{
+  sdcard_chipselect_low();
+
+  if (! sdcard_wait_not_busy( 100 * 1000 )) {
+    goto fail;
+  }
+  platform_spi_transaction( m_spi_no, 8, STOP_TRAN_TOKEN, 0, 0, 0, 0, 0 );
+  if (! sdcard_wait_not_busy( 100 * 1000 )) {
+    goto fail;
+  }
+
+  sdcard_chipselect_high();
+  return TRUE;
+
+  fail:
+  m_error = SD_CARD_ERROR_STOP_TRAN;
+  sdcard_chipselect_high();
+  return FALSE;
+}
+
+int platform_sdcard_write_blocks( uint8_t ss_pin, uint32_t block, size_t num, const uint8_t *src )
+{
+  CHECK_SSPIN(ss_pin);
+
+  if (sdcard_acmd( ACMD23, num )) {
+    m_error = SD_CARD_ERROR_ACMD23;
+    goto fail;
+  }
+  // generate byte address for pre-SDHC types
+  if (m_type != SD_CARD_TYPE_SDHC) {
+    block <<= 9;
+  }
+  if (sdcard_command( CMD25, block )) {
+    m_error = SD_CARD_ERROR_CMD25;
+    goto fail;
+  }
+  sdcard_chipselect_high();
+
+  for (size_t b = 0; b < num; b++, src += 512) {
+    sdcard_chipselect_low();
+
+    // wait for previous write to finish
+    if (! sdcard_wait_not_busy( 100 * 1000 )) {
+      goto fail_write;
+    }
+    if (! sdcard_write_data( WRITE_MULTIPLE_TOKEN, src )) {
+      goto fail_write;
+    }
+
+    sdcard_chipselect_high();
+  }
+
+  return sdcard_write_stop();
+
+  fail_write:
+  m_error = SD_CARD_ERROR_WRITE_MULTIPLE;
+  fail:
+  sdcard_chipselect_high();
+  return FALSE;
+}

+ 17 - 0
app/platform/sdcard.h

@@ -0,0 +1,17 @@
+#ifndef _SDCARD_H
+#define _SDCARD_H
+
+#include "c_types.h"
+
+int platform_sdcard_init( uint8_t spi_no, uint8_t ss_pin );
+int platform_sdcard_status( void );
+int platform_sdcard_error( void );
+int platform_sdcard_type( void );
+int platform_sdcard_read_block( uint8_t ss_pin, uint32_t block, uint8_t *dst );
+int platform_sdcard_read_blocks( uint8_t ss_pin, uint32_t block, size_t num, uint8_t *dst );
+int platform_sdcard_read_csd( uint8_t ss_pin, uint8_t *csd );
+int platform_sdcard_read_cid( uint8_t ss_pin, uint8_t *cid );
+int platform_sdcard_write_block( uint8_t ss_pin, uint32_t block, const uint8_t *src );
+int platform_sdcard_write_blocks( uint8_t ss_pin, uint32_t block, size_t num, const uint8_t *src );
+
+#endif

+ 469 - 0
app/platform/vfs.c

@@ -0,0 +1,469 @@
+
+
+#include "c_stdlib.h"
+#include "vfs.h"
+
+
+#define LDRV_TRAVERSAL 0
+
+
+// ---------------------------------------------------------------------------
+// RTC system interface
+//
+static sint32_t (*rtc_cb)( vfs_time *tm ) = NULL;
+
+// called by operating system
+void vfs_register_rtc_cb( sint32_t (*cb)( vfs_time *tm ) )
+{
+  // allow NULL pointer to unregister callback function
+  rtc_cb = cb;
+}
+
+// called by file system drivers
+sint32_t vfs_get_rtc( vfs_time *tm )
+{
+  if (rtc_cb) {
+    return rtc_cb( tm );
+  }
+
+  return VFS_RES_ERR;
+}
+
+
+static int dir_level = 1;
+
+static const char *normalize_path( const char *path )
+{
+#if ! LDRV_TRAVERSAL
+  return path;
+#else
+  const char *temp = path;
+  size_t len;
+
+  while ((len = c_strlen( temp )) >= 2) {
+    if (temp[0] == '.' && temp[1] == '.') {
+      --dir_level;
+      if (len >= 4 && dir_level > 0) {
+        // prepare next step
+        temp = &(temp[4]);
+      } else {
+        // we're at top, the remainder is expected be an absolute path
+        temp = &(temp[3]);
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (dir_level > 0) {
+    // no traversal on root level
+    return path;
+  } else {
+    // path traverses via root
+    return temp;
+  }
+#endif
+}
+
+
+// ---------------------------------------------------------------------------
+// file system functions
+//
+vfs_vol *vfs_mount( const char *name, int num )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->mount( outname, num );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    vfs_vol *r = fs_fns->mount( outname, num );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return NULL;
+}
+
+int vfs_open( const char *name, const char *mode )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return (int)fs_fns->open( outname, mode );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    int r = (int)fs_fns->open( outname, mode );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return 0;
+}
+
+vfs_dir *vfs_opendir( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->opendir( outname );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    vfs_dir *r = fs_fns->opendir( outname );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return NULL;
+}
+
+vfs_item *vfs_stat( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->stat( outname );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    vfs_item *r = fs_fns->stat( outname );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return NULL;
+}
+
+sint32_t vfs_remove( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->remove( outname );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    sint32_t r = fs_fns->remove( outname );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return VFS_RES_ERR;
+}
+
+sint32_t vfs_rename( const char *oldname, const char *newname )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normoldname = normalize_path( oldname );
+  const char *normnewname = normalize_path( newname );
+  char *oldoutname, *newoutname;
+
+#ifdef BUILD_SPIFFS
+  if (myspiffs_realm( normoldname, &oldoutname, FALSE )) {
+    if (fs_fns = myspiffs_realm( normnewname, &newoutname, FALSE )) {
+      return fs_fns->rename( oldoutname, newoutname );
+    }
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (myfatfs_realm( normoldname, &oldoutname, FALSE )) {
+    if (fs_fns = myfatfs_realm( normnewname, &newoutname, FALSE )) {
+      sint32_t r = fs_fns->rename( oldoutname, newoutname );
+      c_free( oldoutname );
+      c_free( newoutname );
+      return r;
+    }
+    c_free( oldoutname );
+  }
+#endif
+
+  return -1;
+}
+
+sint32_t vfs_mkdir( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  // not supported
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    sint32_t r = fs_fns->mkdir( outname );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return VFS_RES_ERR;
+}
+
+sint32_t vfs_fsinfo( const char *name, uint32_t *total, uint32_t *used )
+{
+  vfs_fs_fns *fs_fns;
+  char *outname;
+
+  if (!name) name = "";  // current drive
+
+  const char *normname = normalize_path( name );
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->fsinfo( total, used );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    c_free( outname );
+    return fs_fns->fsinfo( total, used );
+  }
+#endif
+
+  return VFS_RES_ERR;
+}
+
+sint32_t vfs_fscfg( const char *name, uint32_t *phys_addr, uint32_t *phys_size)
+{
+  vfs_fs_fns *fs_fns;
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( "/FLASH", &outname, FALSE )) {
+    return fs_fns->fscfg( phys_addr, phys_size );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  // not supported
+#endif
+
+  // Error
+  return VFS_RES_ERR;
+}
+
+sint32_t vfs_format( void )
+{
+  vfs_fs_fns *fs_fns;
+  char *outname;
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( "/FLASH", &outname, FALSE )) {
+    return fs_fns->format();
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  // not supported
+#endif
+
+  // Error
+  return 0;
+}
+
+sint32_t vfs_chdir( const char *path )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normpath = normalize_path( path );
+  const char *level;
+  char *outname;
+  int ok = VFS_RES_ERR;
+
+#if LDRV_TRAVERSAL
+  // track dir level
+  if (normpath[0] == '/') {
+    dir_level = 0;
+    level = &(normpath[1]);
+  } else {
+    level = normpath;
+  }
+  while (c_strlen( level ) > 0) {
+    dir_level++;
+    if (level = c_strchr( level, '/' )) {
+      level++;
+    } else {
+      break;
+    }
+  }
+#endif
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normpath, &outname, TRUE )) {
+    // our SPIFFS integration doesn't support directories
+    if (c_strlen( outname ) == 0) {
+      ok = VFS_RES_OK;
+    }
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normpath, &outname, TRUE )) {
+    if (c_strchr( outname, ':' )) {
+      // need to set FatFS' default drive
+      fs_fns->chdrive( outname );
+      // and force chdir to root in case path points only to root
+      fs_fns->chdir( "/" );
+    }
+    if (fs_fns->chdir( outname ) == VFS_RES_OK) {
+      ok = VFS_RES_OK;
+    }
+    c_free( outname );
+  }
+#endif
+
+  return ok == VFS_RES_OK ? VFS_RES_OK : VFS_RES_ERR;
+}
+
+sint32_t vfs_errno( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  const char *normname = normalize_path( name );
+  char *outname;
+
+  if (!name) name = "";  // current drive
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    return fs_fns->ferrno( );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    sint32_t r = fs_fns->ferrno( );
+    c_free( outname );
+    return r;
+  }
+#endif
+
+  return VFS_RES_ERR;
+}
+
+sint32_t vfs_ferrno( int fd )
+{
+  vfs_file *f = (vfs_file *)fd;
+
+  if (f) {
+    return f->fns->ferrno ? f->fns->ferrno( f ) : 0;
+  } else {
+    vfs_fs_fns *fs_fns;
+    const char *name = "";  // current drive
+    char *outname;
+
+#ifdef BUILD_SPIFFS
+    if (fs_fns = myspiffs_realm( name, &outname, FALSE )) {
+      return fs_fns->ferrno( );
+    }
+#endif
+
+#ifdef BUILD_FATFS
+    if (fs_fns = myfatfs_realm( name, &outname, FALSE )) {
+      sint32_t r = fs_fns->ferrno( );
+      c_free( outname );
+      return r;
+    }
+#endif
+  }
+}
+
+
+void vfs_clearerr( const char *name )
+{
+  vfs_fs_fns *fs_fns;
+  char *outname;
+
+  if (!name) name = "";  // current drive
+
+  const char *normname = normalize_path( name );
+
+#ifdef BUILD_SPIFFS
+  if (fs_fns = myspiffs_realm( normname, &outname, FALSE )) {
+    fs_fns->clearerr( );
+  }
+#endif
+
+#ifdef BUILD_FATFS
+  if (fs_fns = myfatfs_realm( normname, &outname, FALSE )) {
+    fs_fns->clearerr( );
+    c_free( outname );
+  }
+#endif
+}
+
+const char *vfs_basename( const char *path )
+{
+  const char *basename;
+
+  // deduce basename (incl. extension) for length check
+  if (basename = c_strrchr( path, '/' )) {
+    basename++;
+  } else if (basename = c_strrchr( path, ':' )) {
+    basename++;
+  } else {
+    basename = path;
+  }
+
+  return basename;
+}
+
+
+// ---------------------------------------------------------------------------
+// supplementary functions
+//
+int vfs_getc( int fd )
+{
+  unsigned char c = 0xFF;
+  sint32_t res;
+
+  if(!vfs_eof( fd )) {
+    if (1 != vfs_read( fd, &c, 1 )) {
+      NODE_DBG("getc errno %i\n", vfs_ferrno( fd ));
+      return VFS_EOF;
+    } else {
+      return (int)c;
+    }
+  }
+  return VFS_EOF;
+}
+
+int vfs_ungetc( int c, int fd )
+{
+  return vfs_lseek( fd, -1, VFS_SEEK_CUR );
+}

+ 248 - 0
app/platform/vfs.h

@@ -0,0 +1,248 @@
+
+#ifndef __VFS_H__
+#define __VFS_H__
+
+#include "vfs_int.h"
+
+// DEPRECATED, DON'T USE
+// Check for fd != 0 instead
+#define FS_OPEN_OK 1
+
+// ---------------------------------------------------------------------------
+// file functions
+//
+
+// vfs_close - close file descriptor and free memory
+//   fd: file descriptor
+//   Returns: VFS_RES_OK or negative value in case of error
+inline sint32_t vfs_close( int fd ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->close( f ) : VFS_RES_ERR;
+}
+
+// vfs_read - read data from file
+//   fd: file descriptor
+//   ptr: destination data buffer
+//   len: requested length
+//   Returns: Number of bytes read, or VFS_RES_ERR in case of error
+inline sint32_t vfs_read( int fd, void *ptr, size_t len ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->read( f, ptr, len ) : VFS_RES_ERR;
+}
+
+// vfs_write - write data to file
+//   fd: file descriptor
+//   ptr: source data buffer
+//   len: requested length
+//   Returns: Number of bytes written, or VFS_RES_ERR in case of error
+inline sint32_t vfs_write( int fd, const void *ptr, size_t len ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->write( f, ptr, len ) : VFS_RES_ERR;
+}
+
+int vfs_getc( int fd );
+
+int vfs_ungetc( int c, int fd );
+
+// vfs_lseek - move read/write pointer
+//   fd: file descriptor
+//   off: offset
+//   whence: VFS_SEEK_SET - set pointer to off
+//           VFS_SEEK_CUR - set pointer to current position + off
+//           VFS_SEEK_END - set pointer to end of file + off
+//   Returns: New position, or VFS_RES_ERR in case of error
+inline sint32_t vfs_lseek( int fd, sint32_t off, int whence ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->lseek( f, off, whence ) : VFS_RES_ERR;
+}
+
+// vfs_eof - test for end-of-file
+//   fd: file descriptor
+//   Returns: 0 if not at end, != 0 if end of file
+inline sint32_t vfs_eof( int fd ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->eof( f ) : VFS_RES_ERR;
+}
+
+// vfs_tell - get read/write position
+//   fd: file descriptor
+//   Returns: Current position
+inline sint32_t vfs_tell( int fd ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->tell( f ) : VFS_RES_ERR;
+}
+
+// vfs_flush - flush write cache to file
+//   fd: file descriptor
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+inline sint32_t vfs_flush( int fd ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f ? f->fns->flush( f ) : VFS_RES_ERR;
+}
+
+// vfs_size - get current file size
+//   fd: file descriptor
+//   Returns: File size
+inline uint32_t vfs_size( int fd ) {
+  vfs_file *f = (vfs_file *)fd;
+  return f && f->fns->size ? f->fns->size( f ) : 0;
+}
+
+// vfs_ferrno - get file system specific errno
+//   fd: file descriptor
+//   Returns: errno
+sint32_t vfs_ferrno( int fd );
+
+// ---------------------------------------------------------------------------
+// dir functions
+//
+
+// vfs_closedir - close directory descriptor and free memory
+//   dd: dir descriptor
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+inline sint32_t vfs_closedir( vfs_dir *dd ) { return dd->fns->close( dd ); }
+
+// vfs_readdir - read next directory item
+//   dd: dir descriptor
+//   Returns: item object, or NULL in case of error
+inline vfs_item  *vfs_readdir( vfs_dir *dd ) { return dd->fns->readdir( dd ); }
+
+// ---------------------------------------------------------------------------
+// dir item functions
+//
+
+// vfs_closeitem - close directory item and free memory
+//   di: item descriptor
+//   Returns: nothing
+inline void vfs_closeitem( vfs_item *di ) { return di->fns->close( di ); }
+
+// vfs_item_size - get item's size
+//   di: item descriptor
+//   Returns: Item size
+inline uint32_t vfs_item_size( vfs_item *di ) { return di->fns->size( di ); }
+
+// vfs_item_time - get item's modification time
+//   di: item descriptor
+//   Returns: Item modification time
+inline sint32_t vfs_item_time( vfs_item *di, struct vfs_time *tm ) { return di->fns->time ? di->fns->time( di, tm ) : VFS_RES_ERR; }
+
+// vfs_item_name - get item's name
+//   di: item descriptor
+//   Returns: Item name
+inline const char *vfs_item_name( vfs_item *di ) { return di->fns->name( di ); }
+
+// vfs_item_is_dir - check for directory
+//   di: item descriptor
+//   Returns: >0 if item is a directory, 0 if not
+inline sint32_t vfs_item_is_dir( vfs_item *di ) { return di->fns->is_dir ? di->fns->is_dir( di ) : 0; }
+
+// vfs_item_is_rdonly - check for read-only
+//   di: item descriptor
+//   Returns: >0 if item is read only, 0 if not
+inline sint32_t vfs_item_is_rdonly( vfs_item *di ) { return di->fns->is_rdonly ? di->fns->is_rdonly( di ) : 0; }
+
+// vfs_item_is_hidden - check for hidden attribute
+//   di: item descriptor
+//   Returns: >0 if item is hidden, 0 if not
+inline sint32_t vfs_item_is_hidden( vfs_item *di ) { return di->fns->is_hidden ? di->fns->is_hidden( di ) : 0; }
+
+// vfs_item_is_sys - check for sys attribute
+//   di: item descriptor
+//   Returns: >0 if item is sys, 0 if not
+inline sint32_t vfs_item_is_sys( vfs_item *di ) { return di->fns->is_sys ? di->fns->is_sys( di ) : 0; }
+
+// vfs_item_is_arch - check for archive attribute
+//   di: item descriptor
+//   Returns: >0 if item is archive, 0 if not
+inline sint32_t vfs_item_is_arch( vfs_item *di ) { return di->fns->is_arch ? di->fns->is_arch( di ) : 0; }
+
+// ---------------------------------------------------------------------------
+// volume functions
+//
+
+// vfs_umount - unmount logical drive and free memory
+//   vol: volume object
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+inline sint32_t vfs_umount( vfs_vol *vol ) { return vol->fns->umount( vol ); }
+
+// ---------------------------------------------------------------------------
+// file system functions
+//
+
+// vfs_mount - unmount logical drive
+//   name: name of logical drive
+//   num: drive's physical number (eg. SS/CS pin), negative values are ignored
+//   Returns: Volume object, or NULL in case of error
+vfs_vol  *vfs_mount( const char *name, int num );
+
+// vfs_open - open file
+//   name: file name
+//   mode: open mode
+//   Returns: File descriptor, or NULL in case of error
+int vfs_open( const char *name, const char *mode );
+
+// vfs_opendir - open directory
+//   name: dir name
+//   Returns: Directory descriptor, or NULL in case of error
+vfs_dir  *vfs_opendir( const char *name );
+
+// vfs_stat - stat file or directory
+//   name: file or directory name
+//   Returns: Item object, or NULL in case of error
+vfs_item *vfs_stat( const char *name );
+
+// vfs_remove - remove file or directory
+//   name: file or directory name
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t  vfs_remove( const char *name );
+
+// vfs_rename - rename file or directory
+//   name: file or directory name
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t  vfs_rename( const char *oldname, const char *newname );
+
+// vfs_mkdir - create directory
+//   name: directory name
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t  vfs_mkdir( const char *name );
+
+// vfs_fsinfo - get file system info
+//   name: logical drive identifier
+//   total: receives total amount
+//   used: received used amount
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t  vfs_fsinfo( const char *name, uint32_t *total, uint32_t *used );
+
+// vfs_format - format file system
+//   Returns: 1, or 0 in case of error
+sint32_t  vfs_format( void );
+
+// vfs_chdir - change default directory
+//   path: new default directory
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t  vfs_chdir( const char *path );
+
+// vfs_fscfg - query configuration settings of file system
+//   phys_addr: pointer to store physical address information
+//   phys_size: pointer to store physical size information
+//   Returns: VFS_RES_OK, or VFS_RES_ERR in case of error
+sint32_t vfs_fscfg( const char *name, uint32_t *phys_addr, uint32_t *phys_size);
+
+// vfs_errno - get file system specific errno
+//   name: logical drive identifier
+//   Returns: errno
+sint32_t  vfs_errno( const char *name );
+
+// vfs_clearerr - cleaer file system specific errno
+void      vfs_clearerr( const char *name );
+
+// vfs_register_rtc_cb - register callback function for RTC query
+//   cb: pointer to callback function
+void vfs_register_rtc_cb( sint32_t (*cb)( vfs_time *tm ) );
+
+// vfs_basename - identify basename (incl. extension)
+//   path: full file system path
+//   Returns: pointer to basename within path string
+const char *vfs_basename( const char *path );
+
+#endif

+ 136 - 0
app/platform/vfs_int.h

@@ -0,0 +1,136 @@
+// internal definitions for vfs
+
+#ifndef __VFS_INT_H__
+#define __VFS_INT_H__
+
+#include <c_string.h>
+#include <c_stdint.h>
+
+#if 0
+#include "spiffs.h"
+
+#include "fatfs_prefix_lib.h"
+#include "ff.h"
+#endif
+
+
+#define VFS_EOF -1
+
+enum vfs_filesystems {
+  VFS_FS_NONE = 0,
+  VFS_FS_SPIFFS,
+  VFS_FS_FATFS
+};
+
+enum vfs_seek {
+  VFS_SEEK_SET = 0,
+  VFS_SEEK_CUR,
+  VFS_SEEK_END
+};
+
+enum vfs_result {
+  VFS_RES_OK  = 0,
+  VFS_RES_ERR = -1
+};
+
+
+struct vfs_time {
+  int year, mon, day;
+  int hour, min, sec;
+};
+typedef struct vfs_time vfs_time;
+
+// generic file descriptor
+struct vfs_file {
+  int fs_type;
+  const struct vfs_file_fns *fns;
+};
+typedef const struct vfs_file vfs_file;
+
+// file descriptor functions
+struct vfs_file_fns {
+  sint32_t (*close)( const struct vfs_file *fd );
+  sint32_t (*read)( const struct vfs_file *fd, void *ptr, size_t len );
+  sint32_t (*write)( const struct vfs_file *fd, const void *ptr, size_t len );
+  sint32_t (*lseek)( const struct vfs_file *fd, sint32_t off, int whence );
+  sint32_t (*eof)( const struct vfs_file *fd );
+  sint32_t (*tell)( const struct vfs_file *fd );
+  sint32_t (*flush)( const struct vfs_file *fd );
+  uint32_t (*size)( const struct vfs_file *fd );
+  sint32_t (*ferrno)( const struct vfs_file *fd );
+};
+typedef const struct vfs_file_fns vfs_file_fns;
+
+// generic dir item descriptor
+struct vfs_item {
+  int fs_type;
+  const struct vfs_item_fns *fns;
+};
+typedef const struct vfs_item vfs_item;
+
+// directory item functions
+struct vfs_item_fns {
+  void (*close)( const struct vfs_item *di );
+  uint32_t (*size)( const struct vfs_item *di );
+  sint32_t (*time)( const struct vfs_item *di, struct vfs_time *tm );
+  const char *(*name)( const struct vfs_item *di );
+  sint32_t (*is_dir)( const struct vfs_item *di );
+  sint32_t (*is_rdonly)( const struct vfs_item *di );
+  sint32_t (*is_hidden)( const struct vfs_item *di );
+  sint32_t (*is_sys)( const struct vfs_item *di );
+  sint32_t (*is_arch)( const struct vfs_item *di );
+};
+typedef const struct vfs_item_fns vfs_item_fns;
+
+// generic dir descriptor
+struct vfs_dir {
+  int fs_type;
+  const struct vfs_dir_fns *fns;
+};
+typedef const struct vfs_dir vfs_dir;
+
+// dir descriptor functions
+struct vfs_dir_fns {
+  sint32_t (*close)( const struct vfs_dir *dd );
+  vfs_item *(*readdir)( const struct vfs_dir *dd );
+};
+typedef const struct vfs_dir_fns vfs_dir_fns;
+
+// generic volume descriptor
+struct vfs_vol {
+  int fs_type;
+  const struct vfs_vol_fns *fns;
+};
+typedef const struct vfs_vol vfs_vol;
+
+// volume functions
+struct vfs_vol_fns {
+  sint32_t (*umount)( const struct vfs_vol *vol );
+};
+typedef const struct vfs_vol_fns vfs_vol_fns;
+
+struct vfs_fs_fns {
+  vfs_vol  *(*mount)( const char *name, int num );
+  vfs_file *(*open)( const char *name, const char *mode );
+  vfs_dir  *(*opendir)( const char *name );
+  vfs_item *(*stat)( const char *name );
+  sint32_t  (*remove)( const char *name );
+  sint32_t  (*rename)( const char *oldname, const char *newname );
+  sint32_t  (*mkdir)( const char *name );
+  sint32_t  (*fsinfo)( uint32_t *total, uint32_t *used );
+  sint32_t  (*fscfg)( uint32_t *phys_addr, uint32_t *phys_size );
+  sint32_t  (*format)( void );
+  sint32_t  (*chdrive)( const char * );
+  sint32_t  (*chdir)( const char * );
+  sint32_t  (*ferrno)( void );
+  void      (*clearerr)( void );
+};
+typedef const struct vfs_fs_fns vfs_fs_fns;
+
+
+vfs_fs_fns *myspiffs_realm( const char *inname, char **outname, int set_current_drive );
+vfs_fs_fns *myfatfs_realm( const char *inname, char **outname, int set_current_drive );
+
+sint32_t vfs_get_rtc( vfs_time *tm );
+
+#endif

+ 391 - 71
app/spiffs/spiffs.c

@@ -204,101 +204,421 @@ int myspiffs_format( void )
   return myspiffs_mount();
 }
 
-int myspiffs_check( void )
-{
-  // ets_wdt_disable();
-  // int res = (int)SPIFFS_check(&fs);
-  // ets_wdt_enable();
-  // return res;
+#if 0
+void test_spiffs() {
+  char buf[12];
+
+  // Surely, I've mounted spiffs before entering here
+  
+  spiffs_file fd = SPIFFS_open(&fs, "my_file", SPIFFS_CREAT | SPIFFS_TRUNC | SPIFFS_RDWR, 0);
+  if (SPIFFS_write(&fs, fd, (u8_t *)"Hello world", 12) < 0) NODE_DBG("errno %i\n", SPIFFS_errno(&fs));
+  SPIFFS_close(&fs, fd); 
+
+  fd = SPIFFS_open(&fs, "my_file", SPIFFS_RDWR, 0);
+  if (SPIFFS_read(&fs, fd, (u8_t *)buf, 12) < 0) NODE_DBG("errno %i\n", SPIFFS_errno(&fs));
+  SPIFFS_close(&fs, fd);
+
+  NODE_DBG("--> %s <--\n", buf);
 }
+#endif
 
-int myspiffs_open(const char *name, int flags){
-  return (int)SPIFFS_open(&fs, (char *)name, (spiffs_flags)flags, 0);
+
+// ***************************************************************************
+// vfs API
+// ***************************************************************************
+
+#include <c_stdlib.h>
+#include "vfs_int.h"
+
+#define MY_LDRV_ID "FLASH"
+
+// default current drive
+static int is_current_drive = TRUE;
+
+// forward declarations
+static sint32_t myspiffs_vfs_close( const struct vfs_file *fd );
+static sint32_t myspiffs_vfs_read( const struct vfs_file *fd, void *ptr, size_t len );
+static sint32_t myspiffs_vfs_write( const struct vfs_file *fd, const void *ptr, size_t len );
+static sint32_t myspiffs_vfs_lseek( const struct vfs_file *fd, sint32_t off, int whence );
+static sint32_t myspiffs_vfs_eof( const struct vfs_file *fd );
+static sint32_t myspiffs_vfs_tell( const struct vfs_file *fd );
+static sint32_t myspiffs_vfs_flush( const struct vfs_file *fd );
+static sint32_t myspiffs_vfs_ferrno( const struct vfs_file *fd );
+
+static sint32_t  myspiffs_vfs_closedir( const struct vfs_dir *dd );
+static vfs_item *myspiffs_vfs_readdir( const struct vfs_dir *dd );
+
+static void       myspiffs_vfs_iclose( const struct vfs_item *di );
+static uint32_t   myspiffs_vfs_isize( const struct vfs_item *di );
+//static const struct tm *myspiffs_vfs_time( const struct vfs_item *di );
+static const char *myspiffs_vfs_name( const struct vfs_item *di );
+
+static vfs_vol  *myspiffs_vfs_mount( const char *name, int num );
+static vfs_file *myspiffs_vfs_open( const char *name, const char *mode );
+static vfs_dir  *myspiffs_vfs_opendir( const char *name );
+static vfs_item *myspiffs_vfs_stat( const char *name );
+static sint32_t  myspiffs_vfs_remove( const char *name );
+static sint32_t  myspiffs_vfs_rename( const char *oldname, const char *newname );
+static sint32_t  myspiffs_vfs_fsinfo( uint32_t *total, uint32_t *used );
+static sint32_t  myspiffs_vfs_fscfg( uint32_t *phys_addr, uint32_t *phys_size );
+static sint32_t  myspiffs_vfs_format( void );
+static sint32_t  myspiffs_vfs_errno( void );
+static void      myspiffs_vfs_clearerr( void );
+
+static sint32_t myspiffs_vfs_umount( const struct vfs_vol *vol );
+
+// ---------------------------------------------------------------------------
+// function tables
+//
+static vfs_fs_fns myspiffs_fs_fns = {
+  .mount    = myspiffs_vfs_mount,
+  .open     = myspiffs_vfs_open,
+  .opendir  = myspiffs_vfs_opendir,
+  .stat     = myspiffs_vfs_stat,
+  .remove   = myspiffs_vfs_remove,
+  .rename   = myspiffs_vfs_rename,
+  .mkdir    = NULL,
+  .fsinfo   = myspiffs_vfs_fsinfo,
+  .fscfg    = myspiffs_vfs_fscfg,
+  .format   = myspiffs_vfs_format,
+  .chdrive  = NULL,
+  .chdir    = NULL,
+  .ferrno   = myspiffs_vfs_errno,
+  .clearerr = myspiffs_vfs_clearerr
+};
+
+static vfs_file_fns myspiffs_file_fns = {
+  .close     = myspiffs_vfs_close,
+  .read      = myspiffs_vfs_read,
+  .write     = myspiffs_vfs_write,
+  .lseek     = myspiffs_vfs_lseek,
+  .eof       = myspiffs_vfs_eof,
+  .tell      = myspiffs_vfs_tell,
+  .flush     = myspiffs_vfs_flush,
+  .size      = NULL,
+  .ferrno    = myspiffs_vfs_ferrno
+};
+
+static vfs_item_fns myspiffs_item_fns = {
+  .close     = myspiffs_vfs_iclose,
+  .size      = myspiffs_vfs_isize,
+  .time      = NULL,
+  .name      = myspiffs_vfs_name,
+  .is_dir    = NULL,
+  .is_rdonly = NULL,
+  .is_hidden = NULL,
+  .is_sys    = NULL,
+  .is_arch   = NULL
+};
+
+static vfs_dir_fns myspiffs_dd_fns = {
+  .close     = myspiffs_vfs_closedir,
+  .readdir   = myspiffs_vfs_readdir
+};
+
+
+// ---------------------------------------------------------------------------
+// specific struct extensions
+//
+struct myvfs_file {
+  struct vfs_file vfs_file;
+  spiffs_file fh;
+};
+
+struct myvfs_dir {
+  struct vfs_dir vfs_dir;
+  spiffs_DIR d;
+};
+
+struct myvfs_stat {
+  struct vfs_item vfs_item;
+  spiffs_stat s;
+};
+
+
+// ---------------------------------------------------------------------------
+// stat functions
+//
+#define GET_STAT_S(descr) \
+  const struct myvfs_stat *mystat = (const struct myvfs_stat *)descr; \
+  spiffs_stat *s = (spiffs_stat *)&(mystat->s);
+
+static void myspiffs_vfs_iclose( const struct vfs_item *di ) {
+  // free descriptor memory
+  c_free( (void *)di );
 }
 
-int myspiffs_close( int fd ){
-  return SPIFFS_close(&fs, (spiffs_file)fd);
+static uint32_t myspiffs_vfs_isize( const struct vfs_item *di ) {
+  GET_STAT_S(di);
+
+  return s->size;
 }
-size_t myspiffs_write( int fd, const void* ptr, size_t len ){
-#if 0
-  if(fd==c_stdout || fd==c_stderr){
-    uart0_tx_buffer((u8_t*)ptr, len);
-    return len;
-  }
-#endif
-  int res = SPIFFS_write(&fs, (spiffs_file)fd, (void *)ptr, len);
-  if (res < 0) {
-    NODE_DBG("write errno %i\n", SPIFFS_errno(&fs));
-    return 0;
+
+static const char *myspiffs_vfs_name( const struct vfs_item *di ) {
+  GET_STAT_S(di);
+
+  return s->name;
+}
+
+
+// ---------------------------------------------------------------------------
+// volume functions
+//
+static sint32_t myspiffs_vfs_umount( const struct vfs_vol *vol ) {
+  // not implemented
+
+  return VFS_RES_ERR;
+}
+
+
+// ---------------------------------------------------------------------------
+// dir functions
+//
+#define GET_DIR_D(descr) \
+  const struct myvfs_dir *mydd = (const struct myvfs_dir *)descr; \
+  spiffs_DIR *d = (spiffs_DIR *)&(mydd->d);
+
+static sint32_t myspiffs_vfs_closedir( const struct vfs_dir *dd ) {
+  GET_DIR_D(dd);
+
+  sint32_t res = SPIFFS_closedir( d );
+
+  // free descriptor memory
+  c_free( (void *)dd );
+}
+
+static vfs_item *myspiffs_vfs_readdir( const struct vfs_dir *dd ) {
+  GET_DIR_D(dd);
+  struct myvfs_stat *stat;
+  struct spiffs_dirent dirent;
+
+  if (stat = c_malloc( sizeof( struct myvfs_stat ) )) {
+    if (SPIFFS_readdir( d, &dirent )) {
+      stat->vfs_item.fs_type = VFS_FS_FATFS;
+      stat->vfs_item.fns     = &myspiffs_item_fns;
+      // copy entries to vfs' directory item
+      stat->s.size = dirent.size;
+      c_strncpy( stat->s.name, dirent.name, SPIFFS_OBJ_NAME_LEN );
+      return (vfs_item *)stat;
+    } else {
+      c_free( stat );
+    }
   }
+
+  return NULL;
+}
+
+
+// ---------------------------------------------------------------------------
+// file functions
+//
+#define GET_FILE_FH(descr) \
+  const struct myvfs_file *myfd = (const struct myvfs_file *)descr; \
+  spiffs_file fh = myfd->fh;
+
+static sint32_t myspiffs_vfs_close( const struct vfs_file *fd ) {
+  GET_FILE_FH(fd);
+
+  sint32_t res = SPIFFS_close( &fs, fh );
+
+  // free descriptor memory
+  c_free( (void *)fd );
+
   return res;
 }
-size_t myspiffs_read( int fd, void* ptr, size_t len){
-  int res = SPIFFS_read(&fs, (spiffs_file)fd, ptr, len);
-  if (res < 0) {
-    NODE_DBG("read errno %i\n", SPIFFS_errno(&fs));
-    return 0;
+
+static sint32_t myspiffs_vfs_read( const struct vfs_file *fd, void *ptr, size_t len ) {
+  GET_FILE_FH(fd);
+
+  return SPIFFS_read( &fs, fh, ptr, len );
+}
+
+static sint32_t myspiffs_vfs_write( const struct vfs_file *fd, const void *ptr, size_t len ) {
+  GET_FILE_FH(fd);
+
+  return SPIFFS_write( &fs, fh, (void *)ptr, len );
+}
+
+static sint32_t myspiffs_vfs_lseek( const struct vfs_file *fd, sint32_t off, int whence ) {
+  GET_FILE_FH(fd);
+  int spiffs_whence;
+
+  switch (whence) {
+  default:
+  case VFS_SEEK_SET:
+    spiffs_whence = SPIFFS_SEEK_SET;
+    break;
+  case VFS_SEEK_CUR:
+    spiffs_whence = SPIFFS_SEEK_CUR;
+    break;
+  case VFS_SEEK_END:
+    spiffs_whence = SPIFFS_SEEK_END;
+    break;
   }
-  return res;
+
+  return SPIFFS_lseek( &fs, fh, off, spiffs_whence );
 }
-int myspiffs_lseek( int fd, int off, int whence ){
-  return SPIFFS_lseek(&fs, (spiffs_file)fd, off, whence);
+
+static sint32_t myspiffs_vfs_eof( const struct vfs_file *fd ) {
+  GET_FILE_FH(fd);
+
+  return SPIFFS_eof( &fs, fh );
+}
+
+static sint32_t myspiffs_vfs_tell( const struct vfs_file *fd ) {
+  GET_FILE_FH(fd);
+
+  return SPIFFS_tell( &fs, fh );
 }
-int myspiffs_eof( int fd ){
-  return SPIFFS_eof(&fs, (spiffs_file)fd);
+
+static sint32_t myspiffs_vfs_flush( const struct vfs_file *fd ) {
+  GET_FILE_FH(fd);
+
+  return SPIFFS_fflush( &fs, fh ) >= 0 ? VFS_RES_OK : VFS_RES_ERR;
 }
-int myspiffs_tell( int fd ){
-  return SPIFFS_tell(&fs, (spiffs_file)fd);
+
+static sint32_t myspiffs_vfs_ferrno( const struct vfs_file *fd ) {
+  return SPIFFS_errno( &fs );
 }
-int myspiffs_getc( int fd ){
-  unsigned char c = 0xFF;
-  int res;
-  if(!myspiffs_eof(fd)){
-    res = SPIFFS_read(&fs, (spiffs_file)fd, &c, 1);
-    if (res != 1) {
-      NODE_DBG("getc errno %i\n", SPIFFS_errno(&fs));
-      return (int)EOF;
+
+
+static int fs_mode2flag(const char *mode){
+  if(c_strlen(mode)==1){
+  	if(c_strcmp(mode,"w")==0)
+  	  return SPIFFS_WRONLY|SPIFFS_CREAT|SPIFFS_TRUNC;
+  	else if(c_strcmp(mode, "r")==0)
+  	  return SPIFFS_RDONLY;
+  	else if(c_strcmp(mode, "a")==0)
+  	  return SPIFFS_WRONLY|SPIFFS_CREAT|SPIFFS_APPEND;
+  	else
+  	  return SPIFFS_RDONLY;
+  } else if (c_strlen(mode)==2){
+  	if(c_strcmp(mode,"r+")==0)
+  	  return SPIFFS_RDWR;
+  	else if(c_strcmp(mode, "w+")==0)
+  	  return SPIFFS_RDWR|SPIFFS_CREAT|SPIFFS_TRUNC;
+  	else if(c_strcmp(mode, "a+")==0)
+  	  return SPIFFS_RDWR|SPIFFS_CREAT|SPIFFS_APPEND;
+  	else
+  	  return SPIFFS_RDONLY;
+  } else {
+  	return SPIFFS_RDONLY;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// filesystem functions
+//
+static vfs_file *myspiffs_vfs_open( const char *name, const char *mode ) {
+  struct myvfs_file *fd;
+  int flags = fs_mode2flag( mode );
+
+  if (fd = (struct myvfs_file *)c_malloc( sizeof( struct myvfs_file ) )) {
+    if (0 < (fd->fh = SPIFFS_open( &fs, name, flags, 0 ))) {
+      fd->vfs_file.fs_type = VFS_FS_SPIFFS;
+      fd->vfs_file.fns     = &myspiffs_file_fns;
+      return (vfs_file *)fd;
     } else {
-      return (int)c;
+      c_free( fd );
     }
   }
-  return (int)EOF;
+
+  return NULL;
 }
-int myspiffs_ungetc( int c, int fd ){
-  return SPIFFS_lseek(&fs, (spiffs_file)fd, -1, SEEK_CUR);
+
+static vfs_dir *myspiffs_vfs_opendir( const char *name ){
+  struct myvfs_dir *dd;
+
+  if (dd = (struct myvfs_dir *)c_malloc( sizeof( struct myvfs_dir ) )) {
+    if (SPIFFS_opendir( &fs, name, &(dd->d) )) {
+      dd->vfs_dir.fs_type = VFS_FS_SPIFFS;
+      dd->vfs_dir.fns     = &myspiffs_dd_fns;
+      return (vfs_dir *)dd;
+    } else {
+      c_free( dd );
+    }
+  }
+
+  return NULL;
 }
-int myspiffs_flush( int fd ){
-  return SPIFFS_fflush(&fs, (spiffs_file)fd);
+
+static vfs_item *myspiffs_vfs_stat( const char *name ) {
+  struct myvfs_stat *s;
+
+  if (s = (struct myvfs_stat *)c_malloc( sizeof( struct myvfs_stat ) )) {
+    if (0 <= SPIFFS_stat( &fs, name, &(s->s) )) {
+      s->vfs_item.fs_type = VFS_FS_SPIFFS;
+      s->vfs_item.fns     = &myspiffs_item_fns;
+      return (vfs_item *)s;
+    } else {
+      c_free( s );
+    }
+  }
+
+  return NULL;
 }
-int myspiffs_error( int fd ){
-  return SPIFFS_errno(&fs);
+
+static sint32_t myspiffs_vfs_remove( const char *name ) {
+  return SPIFFS_remove( &fs, name );
 }
-void myspiffs_clearerr( int fd ){
-  SPIFFS_clearerr(&fs);
+
+static sint32_t myspiffs_vfs_rename( const char *oldname, const char *newname ) {
+  return SPIFFS_rename( &fs, oldname, newname );
 }
-int myspiffs_rename( const char *old, const char *newname ){
-  return SPIFFS_rename(&fs, (char *)old, (char *)newname);
+
+static sint32_t myspiffs_vfs_fsinfo( uint32_t *total, uint32_t *used ) {
+  return SPIFFS_info( &fs, total, used );
 }
-size_t myspiffs_size( int fd ){
-  int32_t curpos = SPIFFS_tell(&fs, (spiffs_file) fd);
-  int32_t size = SPIFFS_lseek(&fs, (spiffs_file) fd, SPIFFS_SEEK_END, 0);
-  (void) SPIFFS_lseek(&fs, (spiffs_file) fd, SPIFFS_SEEK_SET, curpos);
-  return size;
+
+static sint32_t myspiffs_vfs_fscfg( uint32_t *phys_addr, uint32_t *phys_size ) {
+  *phys_addr = fs.cfg.phys_addr;
+  *phys_size = fs.cfg.phys_size;
+  return VFS_RES_OK;
 }
-#if 0
-void test_spiffs() {
-  char buf[12];
 
-  // Surely, I've mounted spiffs before entering here
-  
-  spiffs_file fd = SPIFFS_open(&fs, "my_file", SPIFFS_CREAT | SPIFFS_TRUNC | SPIFFS_RDWR, 0);
-  if (SPIFFS_write(&fs, fd, (u8_t *)"Hello world", 12) < 0) NODE_DBG("errno %i\n", SPIFFS_errno(&fs));
-  SPIFFS_close(&fs, fd); 
+static vfs_vol  *myspiffs_vfs_mount( const char *name, int num ) {
+  // volume descriptor not supported, just return TRUE / FALSE
+  return myspiffs_mount() ? (vfs_vol *)1 : NULL;
+}
 
-  fd = SPIFFS_open(&fs, "my_file", SPIFFS_RDWR, 0);
-  if (SPIFFS_read(&fs, fd, (u8_t *)buf, 12) < 0) NODE_DBG("errno %i\n", SPIFFS_errno(&fs));
-  SPIFFS_close(&fs, fd);
+static sint32_t myspiffs_vfs_format( void ) {
+  return myspiffs_format();
+}
 
-  NODE_DBG("--> %s <--\n", buf);
+static sint32_t myspiffs_vfs_errno( void ) {
+  return SPIFFS_errno( &fs );
+}
+
+static void myspiffs_vfs_clearerr( void ) {
+  SPIFFS_clearerr( &fs );
+}
+
+
+// ---------------------------------------------------------------------------
+// VFS interface functions
+//
+vfs_fs_fns *myspiffs_realm( const char *inname, char **outname, int set_current_drive ) {
+  if (inname[0] == '/') {
+    size_t idstr_len = c_strlen( MY_LDRV_ID );
+    // logical drive is specified, check if it's our id
+    if (0 == c_strncmp( &(inname[1]), MY_LDRV_ID, idstr_len )) {
+      *outname = (char *)&(inname[1 + idstr_len]);
+      if (*outname[0] == '/') {
+        // skip leading /
+        (*outname)++;
+      }
+
+      if (set_current_drive) is_current_drive = TRUE;
+      return &myspiffs_fs_fns;
+    }
+  } else {
+    // no logical drive in patchspec, are we current drive?
+    if (is_current_drive) {
+      *outname = (char *)inname;
+      return &myspiffs_fs_fns;
+    }
+  }
+
+  if (set_current_drive) is_current_drive = FALSE;
+  return NULL;
 }
-#endif

+ 3 - 1
app/spiffs/spiffs_config.h

@@ -14,6 +14,8 @@
 #include "nodemcu_spiffs.h"
 // ----------- >8 ------------
 
+#include "user_config.h"
+
 // compile time switches
 
 // Set generic spiffs debug output call.
@@ -99,7 +101,7 @@
 // zero-termination character, meaning maximum string of characters
 // can at most be SPIFFS_OBJ_NAME_LEN - 1.
 #ifndef SPIFFS_OBJ_NAME_LEN
-#define SPIFFS_OBJ_NAME_LEN             (32)
+#define SPIFFS_OBJ_NAME_LEN             (FS_OBJ_NAME_LEN+1)
 #endif
 
 // Size of buffer allocated on stack used when copying data.

+ 5 - 4
app/user/user_main.c

@@ -12,7 +12,8 @@
 #include "platform.h"
 #include "c_string.h"
 #include "c_stdlib.h"
-#include "flash_fs.h"
+#include "c_stdio.h"
+#include "vfs.h"
 #include "flash_api.h"
 #include "user_interface.h"
 #include "user_exceptions.h"
@@ -103,11 +104,11 @@ void nodemcu_init(void)
     espconn_secure_set_size(ESPCONN_CLIENT, SSL_BUFFER_SIZE);
 #endif
 
-#if defined ( BUILD_SPIFFS )
-    if (!fs_mount()) {
+#ifdef BUILD_SPIFFS
+    if (!vfs_mount("/FLASH", 0)) {
         // Failed to mount -- try reformat
 	c_printf("Formatting file system. Please wait...\n");
-        if (!fs_format()) {
+        if (!vfs_format()) {
             NODE_ERR( "\n*** ERROR ***: unable to format. FS might be compromised.\n" );
             NODE_ERR( "It is advised to re-flash the NodeMCU image.\n" );
         }

+ 139 - 38
docs/en/modules/file.md

@@ -5,10 +5,44 @@
 
 The file module provides access to the file system and its individual files.
 
-The file system is a flat file system, with no notion of directories/folders.
+The file system is a flat file system, with no notion of subdirectories/folders.
 
 Only one file can be open at any given time.
 
+Besides the SPIFFS file system on internal flash, this module can also access FAT partitions on an external SD card is [FatFS is enabled](../sdcard.md).
+
+```lua
+-- open file in flash:
+if file.open("init.lua") then
+  print(file.read())
+  file.close()
+end
+
+-- or with full pathspec
+file.open("/FLASH/init.lua")
+
+-- open file on SD card
+if file.open("/SD0/somefile.txt") then
+  print(file.read())
+  file.close()
+end
+```
+
+## file.chdir()
+
+Change current directory (and drive). This will be used when no drive/directory is prepended to filenames.
+
+Current directory defaults to the root of internal SPIFFS (`/FLASH`) after system start.
+
+#### Syntax
+`file.chdir(dir)`
+
+#### Parameters
+`dir` directory name - `/FLASH`, `/SD0`, `/SD1`, etc.
+
+#### Returns
+`true` on success, `false` otherwise
+
 ## file.close()
 
 Closes the open file, if any.
@@ -25,9 +59,10 @@ none
 #### Example
 ```lua
 -- open 'init.lua', print the first line.
-file.open("init.lua", "r")
-print(file.readline())
-file.close()
+if file.open("init.lua", "r") then
+  print(file.readline())
+  file.close()
+end
 ```
 #### See also
 [`file.open()`](#fileopen)
@@ -76,13 +111,14 @@ none
 #### Example
 ```lua
 -- open 'init.lua' in 'a+' mode
-file.open("init.lua", "a+")
--- write 'foo bar' to the end of the file
-file.write('foo bar')
-file.flush()
--- write 'baz' too
-file.write('baz')
-file.close()
+if file.open("init.lua", "a+") then
+  -- write 'foo bar' to the end of the file
+  file.write('foo bar')
+  file.flush()
+  -- write 'baz' too
+  file.write('baz')
+  file.close()
+end
 ```
 #### See also
 [`file.close()`](#fileclose)
@@ -91,6 +127,8 @@ file.close()
 
 Format the file system. Completely erases any existing file system and writes a new one. Depending on the size of the flash chip in the ESP, this may take several seconds.
 
+Not supported for SD cards.
+
 #### Syntax
 `file.format()`
 
@@ -107,6 +145,8 @@ none
 
 Returns the flash address and physical size of the file system area, in bytes.
 
+Not supported for SD cards.
+
 #### Syntax
 `file.fscfg()`
 
@@ -124,7 +164,7 @@ print(string.format("0x%x", file.fscfg()))
 
 ## file.fsinfo()
 
-Return size information for the file system, in bytes.
+Return size information for the file system. The unit is Byte for SPIFFS and kByte for FatFS.
 
 #### Syntax
 `file.fsinfo()`
@@ -142,7 +182,7 @@ none
 ```lua
 -- get file system info
 remaining, used, total=file.fsinfo()
-print("\nFile system info:\nTotal : "..total.." Bytes\nUsed : "..used.." Bytes\nRemain: "..remaining.." Bytes\n")
+print("\nFile system info:\nTotal : "..total.." (k)Bytes\nUsed : "..used.." (k)Bytes\nRemain: "..remaining.." (k)Bytes\n")
 ```
 
 ## file.list()
@@ -166,6 +206,60 @@ for k,v in pairs(l) do
 end
 ```
 
+## file.mount()
+
+Mounts a FatFs volume on SD card.
+
+Not supported for internal flash.
+
+#### Syntax
+`file.mount(ldrv[, pin])`
+
+#### Parameters
+- `ldrv` name of the logical drive, `SD0:`, `SD1:`, etc.
+- `pin` 1~12, IO index for SS/CS, defaults to 8 if omitted.
+
+#### Returns
+Volume object
+
+#### Example
+```lua
+vol = file.mount("SD0:")
+vol:umount()
+```
+
+## file.on()
+
+Registers callback functions.
+
+Trigger events are:
+- `rtc` deliver current date & time to the file system. Function is expected to return a table containing the fields `year`, `mon`, `day`, `hour`, `min`, `sec` of current date and time. Not supported for internal flash.
+
+#### Syntax
+`file.on(event[, function()])`
+
+#### Parameters
+- `event` string
+- `function()` callback function. Unregisters the callback if `function()` is omitted.
+
+#### Returns
+`nil`
+
+#### Example
+```lua
+sntp.sync(server_ip,
+  function()
+    print("sntp time sync ok")
+    file.on("rtc",
+      function()
+        return rtctime.epoch2cal(rtctime.get())
+      end)
+  end)
+```
+
+#### See also
+[`rtctime.epoch2cal()`](rtctime.md#rtctimepoch2cal)
+
 ## file.open()
 
 Opens a file for access, potentially creating it (for write modes).
@@ -191,9 +285,10 @@ When done with the file, it must be closed using `file.close()`.
 #### Example
 ```lua
 -- open 'init.lua', print the first line.
-file.open("init.lua", "r")
-print(file.readline())
-file.close()
+if file.open("init.lua", "r") then
+  print(file.readline())
+  file.close()
+end
 ```
 #### See also
 - [`file.close()`](#fileclose)
@@ -218,14 +313,16 @@ File content as a string, or nil when EOF
 #### Example
 ```lua
 -- print the first line of 'init.lua'
-file.open("init.lua", "r")
-print(file.read('\n'))
-file.close()
+if file.open("init.lua", "r") then
+  print(file.read('\n'))
+  file.close()
+end
 
 -- print the first 5 bytes of 'init.lua'
-file.open("init.lua", "r")
-print(file.read(5))
-file.close()
+if file.open("init.lua", "r") then
+  print(file.read(5))
+  file.close()
+end
 ```
 
 #### See also
@@ -248,9 +345,10 @@ File content in string, line by line, including EOL('\n'). Return `nil` when EOF
 #### Example
 ```lua
 -- print the first line of 'init.lua'
-file.open("init.lua", "r")
-print(file.readline())
-file.close()
+if file.open("init.lua", "r") then
+  print(file.readline())
+  file.close()
+end
 ```
 #### See also
 - [`file.open()`](#fileopen)
@@ -320,11 +418,12 @@ the resulting file position, or `nil` on error
 
 #### Example
 ```lua
-file.open("init.lua", "r")
--- skip the first 5 bytes of the file
-file.seek("set", 5)
-print(file.readline())
-file.close()
+if file.open("init.lua", "r") then
+  -- skip the first 5 bytes of the file
+  file.seek("set", 5)
+  print(file.readline())
+  file.close()
+end
 ```
 #### See also
 [`file.open()`](#fileopen)
@@ -345,10 +444,11 @@ Write a string to the open file.
 #### Example
 ```lua
 -- open 'init.lua' in 'a+' mode
-file.open("init.lua", "a+")
--- write 'foo bar' to the end of the file
-file.write('foo bar')
-file.close()
+if file.open("init.lua", "a+") then
+  -- write 'foo bar' to the end of the file
+  file.write('foo bar')
+  file.close()
+end
 ```
 
 #### See also
@@ -371,10 +471,11 @@ Write a string to the open file and append '\n' at the end.
 #### Example
 ```lua
 -- open 'init.lua' in 'a+' mode
-file.open("init.lua", "a+")
--- write 'foo bar' to the end of the file
-file.writeline('foo bar')
-file.close()
+if file.open("init.lua", "a+") then
+  -- write 'foo bar' to the end of the file
+  file.writeline('foo bar')
+  file.close()
+end
 ```
 
 #### See also

+ 71 - 0
docs/en/sdcard.md

@@ -0,0 +1,71 @@
+# FAT File System on SD Card
+
+Accessing files on external SD cards is currently only supported from the `file` module. This imposes the same overall restrictions of internal SPIFFS to SD cards:
+- only one file can be opened at a time
+- no support for sub-folders
+- no timestamps
+- no file attributes (read-only, system, etc.)
+
+Work is in progress to extend the `file` API with support for the missing features.
+
+## Enabling FatFs
+
+The FAT file system is implemented by [Chan's FatFs](http://elm-chan.org/fsw/ff/00index_e.html) version [R0.12a](http://elm-chan.org/fsw/ff/ff12a.zip). It's disabled by default to save memory space and has to be enabled before compiling the firmware:
+
+Uncomment `#define BUILD_FATFS` in [`user_config.h`](../../app/include/user_config.h).
+
+## SD Card connection
+
+The SD card is operated in SPI mode, thus the card has to be wired to the respective ESP pins of the HSPI interface. There are several naming schemes used on different adapters - the following list shows alternative terms:
+- `CK, CLK, SCLK` to pin5 / GPIO14
+- `DO, DAT0, MISO` to pin 6 / GPIO12
+- `DI, CMD, MOSI` to pin 7 / GPIO13
+- `CS, DAT3, SS` to pin 8 / GPIO15 recommended
+- `VCC, VDD` to 3V3 supply
+- `VSS, GND` to common ground
+
+Connection of `SS/CS` can be done to any of the GPIOs on pins 1 to 12. This allows coexistence of the SD card with other SPI slaves on the same bus. There's no support for detection of card presence or the write protection switch. These would need to be handled as additional GPIOs in the user application.
+
+!!! caution
+
+    The adapter does not require level shifters since SD and ESP are supposed to be powered with the same voltage. If your specific model contains level shifters then make sure that both sides can be operated at 3V3.
+
+<img src="../img/micro_sd.jpg" alt="1:1 micro-sd adapter" width="200"/>
+<img src="../img/micro_sd_shield.jpg" alt="micro-sd shield" width="200"/>
+
+## Lua bindings
+
+Before mounting the volume(s) on the SD card, you need to initialize the SPI interface from Lua.
+
+```lua
+spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_LOW, 8, 8)
+
+-- initialize other spi slaves
+
+-- then mount the sd
+-- note: the card initialization process during `file.mount()` will set spi divider temporarily to 200 (400 kHz)
+-- it's reverted back to the current user setting before `file.mount()` finishes
+vol = file.mount("/SD0", 8)   -- 2nd parameter is optional for non-standard SS/CS pin
+if not vol then
+  print("retry mounting")
+  vol = file.mount("/SD0", 8)
+  if not vol then
+    error("mount failed")
+  end
+end
+file.open("/SD0/path/to/somefile")
+print(file.read())
+file.close()
+```
+
+!!! note
+
+    If the card doesn't work when calling `file.mount()` for the first time then re-try the command. It's possible that certain cards time out during the first initialization after power-up.
+
+The logical drives are mounted at the root of a unified directory tree where the mount points distinguish between internal flash (`/FLASH`) and the card's paritions (`/SD0` to `/SD3`). Files are accessed via either the absolute hierarchical path or relative to the current working directory. It defaults to `/FLASH` and can be changed with `file.chdir(path)`.
+
+Subdirectories are supported on FAT volumes only.
+
+## Multiple partitions / multiple cards
+
+The mapping from logical volumes (eg. `/SD0`) to partitions on an SD card is defined in [`fatfs_config.h`](../../app/include/fatfs_config.h). More volumes can be added to the `VolToPart` array with any combination of physical drive number (aka SS/CS pin) and partition number. Their names have to be added to `_VOLUME_STRS` in [`ffconf.h`](../../app/fatfs/ffconf.h) as well.

BIN
docs/img/micro_sd.jpg


BIN
docs/img/micro_sd_shield.jpg


+ 2 - 1
mkdocs.yml

@@ -26,7 +26,8 @@ pages:
     - Home: 'en/index.md'
     - Building the firmware: 'en/build.md'
     - Flashing the firmware: 'en/flash.md'
-    - Filesystem notes: 'en/spiffs.md'
+    - Internal filesystem notes: 'en/spiffs.md'
+    - Filesystem on SD card: 'en/sdcard.md'
     - Uploading code: 'en/upload.md'
     - FAQs:
         - Lua Developer FAQ: 'en/lua-developer-faq.md'

+ 3 - 0
tools/pr-build.sh

@@ -11,6 +11,9 @@ cat user_modules.h
 
 # enable SSL
 sed -i.bak 's@//#define CLIENT_SSL_ENABLE@#define CLIENT_SSL_ENABLE@' user_config.h
+
+# enable FATFS
+sed -i 's@//#define BUILD_FATFS@#define BUILD_FATFS@' user_config.h
 cat user_config.h
 
 cd "$TRAVIS_BUILD_DIR"/ld || exit

Niektóre pliki nie zostały wyświetlone z powodu dużej ilości zmienionych plików