Fix errors in the Audio device demos and class driver regarding multiple sample frequ...

[pub/USBasp.git] / Projects / Incomplete / StandaloneProgrammer / Lib / PetiteFATFs / pff.c

diff --git a/Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c b/Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c
index b7b7fb8..29e44f6 100644 (file)
--- a/Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c
+++ b/Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c
@@ -1,5 +1,5 @@
 /*----------------------------------------------------------------------------/
 /*----------------------------------------------------------------------------/

-/  Petit FatFs - FAT file system module  R0.01a                (C)ChaN, 2010
+/  Petit FatFs - FAT file system module  R0.02a                (C)ChaN, 2010

 /-----------------------------------------------------------------------------/
 / Petit FatFs module is an open source software to implement FAT file system to
 / small embedded systems. This is a free software and is opened for education,
 /-----------------------------------------------------------------------------/
 / Petit FatFs module is an open source software to implement FAT file system to
 / small embedded systems. This is a free software and is opened for education,


@@ -13,21 +13,308 @@
 / * Redistributions of source code must retain the above copyright notice.
 /
 /-----------------------------------------------------------------------------/
 / * Redistributions of source code must retain the above copyright notice.
 /
 /-----------------------------------------------------------------------------/

-/ Jun 15,'09 R0.01a  Branched from FatFs R0.07b
+/ Jun 15,'09  R0.01a  First release. (Branched from FatFs R0.07b.)
+/
+/ Dec 14,'09  R0.02   Added multiple code page support.
+/                     Added write funciton.
+/                     Changed stream read mode interface.
+/ Dec 07,'10  R0.02a  Added some configuration options.
+/                     Fixed fails to open objects with DBCS character.

 /----------------------------------------------------------------------------*/
 
 #include "pff.h"               /* Petit FatFs configurations and declarations */
 #include "diskio.h"            /* Declarations of low level disk I/O functions */
 
 
 /----------------------------------------------------------------------------*/
 
 #include "pff.h"               /* Petit FatFs configurations and declarations */
 #include "diskio.h"            /* Declarations of low level disk I/O functions */
 
 

+

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

-   Private Work Area
+   Module Private Definitions

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

-static
-FATFS *FatFs;  /* Pointer to the file system object (logical drive) */
+
+#if _FS_FAT32
+#define LD_CLUST(dir)  (((DWORD)LD_WORD(dir+DIR_FstClusHI)<<16) | LD_WORD(dir+DIR_FstClusLO))
+#else
+#define LD_CLUST(dir)  LD_WORD(dir+DIR_FstClusLO)
+#endif
+
+
+/*--------------------------------------------------------*/
+/* DBCS code ranges and SBCS extend char conversion table */
+
+#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. (OEM) */
+#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,0x21,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 (OEM) */
+#define _DF1S  0
+#define _EXCVT {0x80,0x81,0x45,0x41,0x84,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x8E,0x8F,0x90,0x92,0x92,0x93,0x94,0x95,0x49,0x49,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 (OEM) */
+#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,0xE7,0xE8,0xF1,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 == 775        /* Baltic (OEM) */
+#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        /* Multilingual Latin 1 (OEM) */
+#define _DF1S  0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+                               0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,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,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+                               0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 852        /* Latin 2 (OEM) */
+#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,0x9F, \
+                               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 (OEM) */
+#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 (OEM) */
+#define _DF1S  0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x98,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,0x21,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,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+                               0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0x59,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 858        /* Multilingual Latin 1 + Euro (OEM) */
+#define _DF1S  0
+#define _EXCVT {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0xDE,0x8E,0x8F,0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x59,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
+                               0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0x21,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,0xD1,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+                               0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE7,0xE9,0xEA,0xEB,0xED,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 862        /* Hebrew (OEM) */
+#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,0x21,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 (OEM) */
+#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,0x9d,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 == 874        /* Thai (OEM, Windows) */
+#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 == 1250 /* Central Europe (Windows) */
+#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,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+                               0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xA3,0xB4,0xB5,0xB6,0xB7,0xB8,0xA5,0xAA,0xBB,0xBC,0xBD,0xBC,0xAF, \
+                               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, \
+                               0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */
+#define _DF1S  0
+#define _EXCVT {0x80,0x81,0x82,0x82,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x80,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+                               0xA0,0xA2,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB2,0xA5,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xA3,0xBD,0xBD,0xAF, \
+                               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, \
+                               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}
+
+#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */
+#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,0xAd,0x9B,0x8C,0x9D,0xAE,0x9F, \
+                               0xA0,0x21,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, \
+                               0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1253 /* Greek (Windows) */
+#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,0xA2,0xB8,0xB9,0xBA, \
+                               0xE0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xBC,0xFD,0xBF,0xFF}
+
+#elif _CODE_PAGE == 1254 /* Turkish (Windows) */
+#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,0x8A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+                               0xA0,0x21,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, \
+                               0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */
+#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,0x21,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 == 1256 /* Arabic (Windows) */
+#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,0x8C,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, \
+                               0x41,0xE1,0x41,0xE3,0xE4,0xE5,0xE6,0x43,0x45,0x45,0x45,0x45,0xEC,0xED,0x49,0x49,0xF0,0xF1,0xF2,0xF3,0x4F,0xF5,0xF6,0xF7,0xF8,0x55,0xFA,0x55,0x55,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1257 /* Baltic (Windows) */
+#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,0xA8,0xB9,0xAA,0xBB,0xBC,0xBD,0xBE,0xAF, \
+                               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, \
+                               0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */
+#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,0xAC,0x9D,0x9E,0x9F, \
+                               0xA0,0x21,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, \
+                               0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xEC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xFE,0x9F}
+
+#elif _CODE_PAGE == 1  /* ASCII (for only non-LFN cfg) */
+#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'))
+
+#if _DF1S              /* DBCS configuration */
+
+#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                  /* SBCS configuration */
+
+#define IsDBCS1(c)     0
+#define IsDBCS2(c)     0
+
+#endif /* _DF1S */
+
+
+/* FatFs refers the members in the FAT structures with byte offset instead
+/ of structure member because there are incompatibility of the packing option
+/ between various compilers. */
+
+#define BS_jmpBoot                     0
+#define BS_OEMName                     3
+#define BPB_BytsPerSec         11
+#define BPB_SecPerClus         13
+#define BPB_RsvdSecCnt         14
+#define BPB_NumFATs                    16
+#define BPB_RootEntCnt         17
+#define BPB_TotSec16           19
+#define BPB_Media                      21
+#define BPB_FATSz16                    22
+#define BPB_SecPerTrk          24
+#define BPB_NumHeads           26
+#define BPB_HiddSec                    28
+#define BPB_TotSec32           32
+#define BS_55AA                                510
+
+#define BS_DrvNum                      36
+#define BS_BootSig                     38
+#define BS_VolID                       39
+#define BS_VolLab                      43
+#define BS_FilSysType          54
+
+#define BPB_FATSz32                    36
+#define BPB_ExtFlags           40
+#define BPB_FSVer                      42
+#define BPB_RootClus           44
+#define BPB_FSInfo                     48
+#define BPB_BkBootSec          50
+#define BS_DrvNum32                    64
+#define BS_BootSig32           66
+#define BS_VolID32                     67
+#define BS_VolLab32                    71
+#define BS_FilSysType32                82
+
+#define MBR_Table                      446
+
+#define        DIR_Name                        0
+#define        DIR_Attr                        11
+#define        DIR_NTres                       12
+#define        DIR_CrtTime                     14
+#define        DIR_CrtDate                     16
+#define        DIR_FstClusHI           20
+#define        DIR_WrtTime                     22
+#define        DIR_WrtDate                     24
+#define        DIR_FstClusLO           26
+#define        DIR_FileSize            28
+

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


@@ -37,9 +324,9 @@ FATFS *FatFs;        /* Pointer to the file system object (logical drive) */
 ---------------------------------------------------------------------------*/
 
 
 ---------------------------------------------------------------------------*/
 
 

-/*-----------------------------------------------------------------------*/
-/* String functions                                                      */
-/*-----------------------------------------------------------------------*/
+static
+FATFS *FatFs;  /* Pointer to the file system object (logical drive) */
+

 
 /* Fill memory */
 static
 
 /* Fill memory */
 static


@@ -57,13 +344,6 @@ int mem_cmp (const void* dst, const void* src, int cnt) {
        return r;
 }
 
        return r;
 }
 

-/* Check if chr is contained in the string */
-static
-int chk_chr (const char* str, int chr) {
-       while (*str && *str != chr) str++;
-       return *str;
-}
-

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


@@ -80,10 +360,11 @@ CLUST get_fat (    /* 1:IO error, Else:Cluster status */
        FATFS *fs = FatFs;
 
 
        FATFS *fs = FatFs;
 
 

-       if (clst < 2 || clst >= fs->max_clust)  /* Range check */
+       if (clst < 2 || clst >= fs->n_fatent)   /* Range check */

                return 1;
 
        switch (fs->fs_type) {
                return 1;
 
        switch (fs->fs_type) {

+#if _FS_FAT12

        case FS_FAT12 :
                bc = (WORD)clst; bc += bc / 2;
                ofs = bc % 512; bc /= 512;
        case FS_FAT12 :
                bc = (WORD)clst; bc += bc / 2;
                ofs = bc % 512; bc /= 512;


@@ -95,7 +376,7 @@ CLUST get_fat (      /* 1:IO error, Else:Cluster status */
                }
                wc = LD_WORD(buf);
                return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
                }
                wc = LD_WORD(buf);
                return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);

-
+#endif

        case FS_FAT16 :
                if (disk_readp(buf, fs->fatbase + clst / 256, (WORD)(((WORD)clst % 256) * 2), 2)) break;
                return LD_WORD(buf);
        case FS_FAT16 :
                if (disk_readp(buf, fs->fatbase + clst / 256, (WORD)(((WORD)clst % 256) * 2), 2)) break;
                return LD_WORD(buf);


@@ -125,7 +406,7 @@ DWORD clust2sect (  /* !=0: Sector number, 0: Failed - invalid cluster# */
 
 
        clst -= 2;
 
 
        clst -= 2;

-       if (clst >= (fs->max_clust - 2)) return 0;              /* Invalid cluster# */
+       if (clst >= (fs->n_fatent - 2)) return 0;               /* Invalid cluster# */

        return (DWORD)clst * fs->csize + fs->database;
 }
 
        return (DWORD)clst * fs->csize + fs->database;
 }
 


@@ -147,12 +428,10 @@ FRESULT dir_rewind (
 
        dj->index = 0;
        clst = dj->sclust;
 
        dj->index = 0;
        clst = dj->sclust;

-       if (clst == 1 || clst >= fs->max_clust) /* Check start cluster range */
+       if (clst == 1 || clst >= fs->n_fatent)  /* Check start cluster range */

                return FR_DISK_ERR;
                return FR_DISK_ERR;

-#if _FS_FAT32
-       if (!clst && fs->fs_type == FS_FAT32)   /* Replace cluster# 0 with root cluster# if in FAT32 */
-               clst = fs->dirbase;
-#endif
+       if (_FS_FAT32 && !clst && fs->fs_type == FS_FAT32)      /* Replace cluster# 0 with root cluster# if in FAT32 */
+               clst = (CLUST)fs->dirbase;

        dj->clust = clst;                                               /* Current cluster */
        dj->sect = clst ? clust2sect(clst) : fs->dirbase;       /* Current sector */
 
        dj->clust = clst;                                               /* Current cluster */
        dj->sect = clst ? clust2sect(clst) : fs->dirbase;       /* Current sector */
 


@@ -167,7 +446,7 @@ FRESULT dir_rewind (
 /*-----------------------------------------------------------------------*/
 
 static
 /*-----------------------------------------------------------------------*/
 
 static

-FRESULT dir_next (     /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not streach */
+FRESULT dir_next (     /* FR_OK:Succeeded, FR_NO_FILE:End of table */

        DIR *dj                 /* Pointer to directory object */
 )
 {
        DIR *dj                 /* Pointer to directory object */
 )
 {


@@ -180,7 +459,7 @@ FRESULT dir_next (  /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT an
        if (!i || !dj->sect)    /* Report EOT when index has reached 65535 */
                return FR_NO_FILE;
 
        if (!i || !dj->sect)    /* Report EOT when index has reached 65535 */
                return FR_NO_FILE;
 

-       if (!(i & (16-1))) {    /* Sector changed? */
+       if (!(i % 16)) {                /* Sector changed? */

                dj->sect++;                     /* Next sector */
 
                if (dj->clust == 0) {   /* Static table */
                dj->sect++;                     /* Next sector */
 
                if (dj->clust == 0) {   /* Static table */


@@ -191,7 +470,7 @@ FRESULT dir_next (  /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT an
                        if (((i / 16) & (fs->csize-1)) == 0) {  /* Cluster changed? */
                                clst = get_fat(dj->clust);              /* Get next cluster */
                                if (clst <= 1) return FR_DISK_ERR;
                        if (((i / 16) & (fs->csize-1)) == 0) {  /* Cluster changed? */
                                clst = get_fat(dj->clust);              /* Get next cluster */
                                if (clst <= 1) return FR_DISK_ERR;

-                               if (clst >= fs->max_clust)              /* When it reached end of dynamic table */
+                               if (clst >= fs->n_fatent)               /* When it reached end of dynamic table */

                                        return FR_NO_FILE;                      /* Report EOT */
                                dj->clust = clst;                               /* Initialize data for new cluster */
                                dj->sect = clust2sect(clst);
                                        return FR_NO_FILE;                      /* Report EOT */
                                dj->clust = clst;                               /* Initialize data for new cluster */
                                dj->sect = clust2sect(clst);


@@ -213,17 +492,17 @@ FRESULT dir_next (        /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT an
 
 static
 FRESULT dir_find (
 
 static
 FRESULT dir_find (

-       DIR *dj                 /* Pointer to the directory object linked to the file name */
+       DIR *dj,                /* Pointer to the directory object linked to the file name */
+       BYTE *dir               /* 32-byte working buffer */

 )
 {
        FRESULT res;
 )
 {
        FRESULT res;

-       BYTE c, *dir;
+       BYTE c;

 
 
        res = dir_rewind(dj);                   /* Rewind directory object */
        if (res != FR_OK) return res;
 
 
 
        res = dir_rewind(dj);                   /* Rewind directory object */
        if (res != FR_OK) return res;
 

-       dir = FatFs->buf;

        do {
                res = disk_readp(dir, dj->sect, (WORD)((dj->index % 16) * 32), 32)      /* Read an entry */
                        ? FR_DISK_ERR : FR_OK;
        do {
                res = disk_readp(dir, dj->sect, (WORD)((dj->index % 16) * 32), 32)      /* Read an entry */
                        ? FR_DISK_ERR : FR_OK;


@@ -232,7 +511,7 @@ FRESULT dir_find (
                if (c == 0) { res = FR_NO_FILE; break; }        /* Reached to end of table */
                if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
                        break;
                if (c == 0) { res = FR_NO_FILE; break; }        /* Reached to end of table */
                if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
                        break;

-               res = dir_next(dj);                                                     /* Next entry */
+               res = dir_next(dj);                                     /* Next entry */

        } while (res == FR_OK);
 
        return res;
        } while (res == FR_OK);
 
        return res;


@@ -247,16 +526,16 @@ FRESULT dir_find (
 #if _USE_DIR
 static
 FRESULT dir_read (
 #if _USE_DIR
 static
 FRESULT dir_read (

-       DIR *dj                 /* Pointer to the directory object to store read object name */
+       DIR *dj,                /* Pointer to the directory object to store read object name */
+       BYTE *dir               /* 32-byte working buffer */

 )
 {
        FRESULT res;
 )
 {
        FRESULT res;

-       BYTE a, c, *dir;
+       BYTE a, c;

 
 
        res = FR_NO_FILE;
        while (dj->sect) {
 
 
        res = FR_NO_FILE;
        while (dj->sect) {

-               dir = FatFs->buf;

                res = disk_readp(dir, dj->sect, (WORD)((dj->index % 16) * 32), 32)      /* Read an entry */
                        ? FR_DISK_ERR : FR_OK;
                if (res != FR_OK) break;
                res = disk_readp(dir, dj->sect, (WORD)((dj->index % 16) * 32), 32)      /* Read an entry */
                        ? FR_DISK_ERR : FR_OK;
                if (res != FR_OK) break;


@@ -265,7 +544,7 @@ FRESULT dir_read (
                a = dir[DIR_Attr] & AM_MASK;
                if (c != 0xE5 && c != '.' && !(a & AM_VOL))     /* Is it a valid entry? */
                        break;
                a = dir[DIR_Attr] & AM_MASK;
                if (c != 0xE5 && c != '.' && !(a & AM_VOL))     /* Is it a valid entry? */
                        break;

-               res = dir_next(dj);                             /* Next entry */
+               res = dir_next(dj);                     /* Next entry */

                if (res != FR_OK) break;
        }
 
                if (res != FR_OK) break;
        }
 


@@ -281,6 +560,9 @@ FRESULT dir_read (
 /* Pick a segment and create the object name in directory form           */
 /*-----------------------------------------------------------------------*/
 
 /* Pick a segment and create the object name in directory form           */
 /*-----------------------------------------------------------------------*/
 

+#ifdef _EXCVT
+       static const BYTE cvt[] = _EXCVT;
+#endif

 
 static
 FRESULT create_name (
 
 static
 FRESULT create_name (


@@ -288,7 +570,7 @@ FRESULT create_name (
        const char **path       /* Pointer to pointer to the segment in the path string */
 )
 {
        const char **path       /* Pointer to pointer to the segment in the path string */
 )
 {

-       BYTE c, ni, si, i, *sfn;
+       BYTE c, d, ni, si, i, *sfn;

        const char *p;
 
        /* Create file name in directory form */
        const char *p;
 
        /* Create file name in directory form */


@@ -298,21 +580,28 @@ FRESULT create_name (
        p = *path;
        for (;;) {
                c = p[si++];
        p = *path;
        for (;;) {
                c = p[si++];

-               if (c < ' ' || c == '/') break; /* Break on end of segment */
+               if (c <= ' ' || c == '/') break;        /* Break on end of segment */

                if (c == '.' || i >= ni) {
                if (c == '.' || i >= ni) {

-                       if (ni != 8 || c != '.') return FR_INVALID_NAME;
+                       if (ni != 8 || c != '.') break;

                        i = 8; ni = 11;
                        continue;
                }
                        i = 8; ni = 11;
                        continue;
                }

-               if (c >= 0x7F || chk_chr(" +,;[=\\]\"*:<>\?|", c))      /* Reject unallowable chrs for SFN */
-                       return FR_INVALID_NAME;
-               if (c >='a' && c <= 'z') c -= 0x20;
-               sfn[i++] = c;
+#ifdef _EXCVT
+               if (c >= 0x80)                                  /* To upper extended char (SBCS) */
+                       c = cvt[c - 0x80];
+#endif
+               if (IsDBCS1(c) && i < ni - 1) { /* DBC 1st byte? */
+                       d = p[si++];                            /* Get 2nd byte */
+                       sfn[i++] = c;
+                       sfn[i++] = d;
+               } else {                                                /* Single byte code */
+                       if (IsLower(c)) c -= 0x20;      /* toupper */
+                       sfn[i++] = c;
+               }

        }
        }

-       if (!i) return FR_INVALID_NAME;         /* Reject null string */

        *path = &p[si];                                         /* Rerurn pointer to the next segment */
 
        *path = &p[si];                                         /* Rerurn pointer to the next segment */
 

-       sfn[11] = (c < ' ') ? 1 : 0;            /* Set last segment flag if end of path */
+       sfn[11] = (c <= ' ') ? 1 : 0;           /* Set last segment flag if end of path */

 
        return FR_OK;
 }
 
        return FR_OK;
 }


@@ -327,16 +616,16 @@ FRESULT create_name (
 static
 void get_fileinfo (            /* No return code */
        DIR *dj,                        /* Pointer to the directory object */
 static
 void get_fileinfo (            /* No return code */
        DIR *dj,                        /* Pointer to the directory object */

+       BYTE *dir,                      /* 32-byte working buffer */

        FILINFO *fno            /* Pointer to store the file information */
 )
 {
        FILINFO *fno            /* Pointer to store the file information */
 )
 {

-       BYTE i, c, *dir;
+       BYTE i, c;

        char *p;
 
 
        p = fno->fname;
        if (dj->sect) {
        char *p;
 
 
        p = fno->fname;
        if (dj->sect) {

-               dir = FatFs->buf;

                for (i = 0; i < 8; i++) {       /* Copy file name body */
                        c = dir[i];
                        if (c == ' ') break;
                for (i = 0; i < 8; i++) {       /* Copy file name body */
                        c = dir[i];
                        if (c == ' ') break;


@@ -369,40 +658,36 @@ void get_fileinfo (               /* No return code */
 static
 FRESULT follow_path (  /* FR_OK(0): successful, !=0: error code */
        DIR *dj,                        /* Directory object to return last directory and found object */
 static
 FRESULT follow_path (  /* FR_OK(0): successful, !=0: error code */
        DIR *dj,                        /* Directory object to return last directory and found object */

+       BYTE *dir,                      /* 32-byte working buffer */

        const char *path        /* Full-path string to find a file or directory */
 )
 {
        FRESULT res;
        const char *path        /* Full-path string to find a file or directory */
 )
 {
        FRESULT res;

-       BYTE *dir;

 
 
 
 

+       while (*path == ' ') path++;            /* Skip leading spaces */

        if (*path == '/') path++;                       /* Strip heading separator */
        dj->sclust = 0;                                         /* Set start directory (always root dir) */
 
        if (*path == '/') path++;                       /* Strip heading separator */
        dj->sclust = 0;                                         /* Set start directory (always root dir) */
 

-       if ((BYTE)*path < ' ') {                        /* Null path means the root directory */
+       if ((BYTE)*path <= ' ') {                       /* Null path means the root directory */

                res = dir_rewind(dj);
                res = dir_rewind(dj);

-               FatFs->buf[0] = 0;
+               dir[0] = 0;

 
        } else {                                                        /* Follow path */
                for (;;) {
                        res = create_name(dj, &path);   /* Get a segment */
                        if (res != FR_OK) break;
 
        } else {                                                        /* Follow path */
                for (;;) {
                        res = create_name(dj, &path);   /* Get a segment */
                        if (res != FR_OK) break;

-                       res = dir_find(dj);                             /* Find it */
+                       res = dir_find(dj, dir);                /* Find it */

                        if (res != FR_OK) {                             /* Could not find the object */
                                if (res == FR_NO_FILE && !*(dj->fn+11))
                                        res = FR_NO_PATH;
                                break;
                        }
                        if (*(dj->fn+11)) break;                /* Last segment match. Function completed. */
                        if (res != FR_OK) {                             /* Could not find the object */
                                if (res == FR_NO_FILE && !*(dj->fn+11))
                                        res = FR_NO_PATH;
                                break;
                        }
                        if (*(dj->fn+11)) break;                /* Last segment match. Function completed. */

-                       dir = FatFs->buf;                               /* There is next segment. Follow the sub directory */

                        if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */
                                res = FR_NO_PATH; break;
                        }
                        if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */
                                res = FR_NO_PATH; break;
                        }

-                       dj->sclust =
-#if _FS_FAT32
-                               ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) | 
-#endif
-                               LD_WORD(dir+DIR_FstClusLO);
+                       dj->sclust = LD_CLUST(dir);

                }
        }
 
                }
        }
 


@@ -429,10 +714,8 @@ BYTE check_fs (    /* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:
 
        if (!disk_readp(buf, sect, BS_FilSysType, 2) && LD_WORD(buf) == 0x4146) /* Check FAT12/16 */
                return 0;
 
        if (!disk_readp(buf, sect, BS_FilSysType, 2) && LD_WORD(buf) == 0x4146) /* Check FAT12/16 */
                return 0;

-#if _FS_FAT32
-       if (!disk_readp(buf, sect, BS_FilSysType32, 2) && LD_WORD(buf) == 0x4146)       /* Check FAT32 */
+       if (_FS_FAT32 && !disk_readp(buf, sect, BS_FilSysType32, 2) && LD_WORD(buf) == 0x4146)  /* Check FAT32 */

                return 0;
                return 0;

-#endif

        return 1;
 }
 
        return 1;
 }
 


@@ -497,10 +780,15 @@ FRESULT pf_mount (
        mclst = (tsect                                          /* Last cluster# + 1 */
                - LD_WORD(buf+BPB_RsvdSecCnt-13) - fsize - fs->n_rootdir / 16
                ) / fs->csize + 2;
        mclst = (tsect                                          /* Last cluster# + 1 */
                - LD_WORD(buf+BPB_RsvdSecCnt-13) - fsize - fs->n_rootdir / 16
                ) / fs->csize + 2;

-       fs->max_clust = (CLUST)mclst;
+       fs->n_fatent = (CLUST)mclst;

 
 

-       fmt = FS_FAT12;                                                 /* Determine the FAT sub type */
-       if (mclst >= 0xFF7) fmt = FS_FAT16;             /* Number of clusters >= 0xFF5 */
+       fmt = FS_FAT16;                                                 /* Determine the FAT sub type */
+       if (mclst < 0xFF7)                                              /* Number of clusters < 0xFF5 */
+#if _FS_FAT12
+               fmt = FS_FAT12;
+#else
+               return FR_NO_FILESYSTEM;
+#endif

        if (mclst >= 0xFFF7)                                    /* Number of clusters >= 0xFFF5 */
 #if _FS_FAT32
                fmt = FS_FAT32;
        if (mclst >= 0xFFF7)                                    /* Number of clusters >= 0xFFF5 */
 #if _FS_FAT32
                fmt = FS_FAT32;


@@ -509,11 +797,9 @@ FRESULT pf_mount (
 #endif
 
        fs->fs_type = fmt;              /* FAT sub-type */
 #endif
 
        fs->fs_type = fmt;              /* FAT sub-type */

-#if _FS_FAT32
-       if (fmt == FS_FAT32)
+       if (_FS_FAT32 && fmt == FS_FAT32)

                fs->dirbase = LD_DWORD(buf+(BPB_RootClus-13));  /* Root directory start cluster */
        else
                fs->dirbase = LD_DWORD(buf+(BPB_RootClus-13));  /* Root directory start cluster */
        else

-#endif

                fs->dirbase = fs->fatbase + fsize;                              /* Root directory start sector (lba) */
        fs->database = fs->fatbase + fsize + fs->n_rootdir / 16;        /* Data start sector (lba) */
 
                fs->dirbase = fs->fatbase + fsize;                              /* Root directory start sector (lba) */
        fs->database = fs->fatbase + fsize + fs->n_rootdir / 16;        /* Data start sector (lba) */
 


@@ -544,21 +830,16 @@ FRESULT pf_open (
                return FR_NOT_ENABLED;
 
        fs->flag = 0;
                return FR_NOT_ENABLED;
 
        fs->flag = 0;

-       fs->buf = dir;

        dj.fn = sp;
        dj.fn = sp;

-       res = follow_path(&dj, path);   /* Follow the file path */
-       if (res != FR_OK) return res;   /* Follow failed */
+       res = follow_path(&dj, dir, path);      /* Follow the file path */
+       if (res != FR_OK) return res;           /* Follow failed */

        if (!dir[0] || (dir[DIR_Attr] & AM_DIR))        /* It is a directory */
                return FR_NO_FILE;
 
        if (!dir[0] || (dir[DIR_Attr] & AM_DIR))        /* It is a directory */
                return FR_NO_FILE;
 

-       fs->org_clust =                                         /* File start cluster */
-#if _FS_FAT32
-               ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) |
-#endif
-               LD_WORD(dir+DIR_FstClusLO);
+       fs->org_clust = LD_CLUST(dir);                  /* File start cluster */

        fs->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
        fs->fptr = 0;                                           /* File pointer */
        fs->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
        fs->fptr = 0;                                           /* File pointer */

-       fs->flag = FA_READ;
+       fs->flag = FA_OPENED;

 
        return FR_OK;
 }
 
        return FR_OK;
 }


@@ -569,10 +850,11 @@ FRESULT pf_open (
 /*-----------------------------------------------------------------------*/
 /* Read File                                                             */
 /*-----------------------------------------------------------------------*/
 /*-----------------------------------------------------------------------*/
 /* Read File                                                             */
 /*-----------------------------------------------------------------------*/

+#if _USE_READ

 
 FRESULT pf_read (
 
 FRESULT pf_read (

-       void* dest,             /* Pointer to the destination object */
-       WORD btr,               /* Number of bytes to read (bit15:destination) */
+       void* buff,             /* Pointer to the read buffer (NULL:Forward data to the stream)*/
+       WORD btr,               /* Number of bytes to read */

        WORD* br                /* Pointer to number of bytes read */
 )
 {
        WORD* br                /* Pointer to number of bytes read */
 )
 {


@@ -580,74 +862,137 @@ FRESULT pf_read (
        CLUST clst;
        DWORD sect, remain;
        WORD rcnt;
        CLUST clst;
        DWORD sect, remain;
        WORD rcnt;

-       BYTE *rbuff = dest;
+       BYTE cs, *rbuff = buff;

        FATFS *fs = FatFs;
 
 
        *br = 0;
        if (!fs) return FR_NOT_ENABLED;         /* Check file system */
        FATFS *fs = FatFs;
 
 
        *br = 0;
        if (!fs) return FR_NOT_ENABLED;         /* Check file system */

-       if (!(fs->flag & FA_READ))
-                       return FR_INVALID_OBJECT;
+       if (!(fs->flag & FA_OPENED))            /* Check if opened */
+               return FR_NOT_OPENED;

 
        remain = fs->fsize - fs->fptr;
 
        remain = fs->fsize - fs->fptr;

-       if (btr > remain) btr = (UINT)remain;                   /* Truncate btr by remaining bytes */
+       if (btr > remain) btr = (WORD)remain;                   /* Truncate btr by remaining bytes */

 
 

-       for ( ;  btr;                                                                   /* Repeat until all data transferred */
-               rbuff += rcnt, fs->fptr += rcnt, *br += rcnt, btr -= rcnt) {
+       while (btr)     {                                                                       /* Repeat until all data transferred */

                if ((fs->fptr % 512) == 0) {                            /* On the sector boundary? */
                if ((fs->fptr % 512) == 0) {                            /* On the sector boundary? */

-                       if ((fs->fptr / 512 % fs->csize) == 0) {        /* On the cluster boundary? */
+                       cs = (BYTE)(fs->fptr / 512 & (fs->csize - 1));  /* Sector offset in the cluster */
+                       if (!cs) {                                                              /* On the cluster boundary? */

                                clst = (fs->fptr == 0) ?                        /* On the top of the file? */
                                        fs->org_clust : get_fat(fs->curr_clust);
                                clst = (fs->fptr == 0) ?                        /* On the top of the file? */
                                        fs->org_clust : get_fat(fs->curr_clust);

-                               if (clst <= 1) {
-                                       fs->flag = 0; return FR_DISK_ERR;
-                               }
+                               if (clst <= 1) goto fr_abort;

                                fs->curr_clust = clst;                          /* Update current cluster */
                                fs->curr_clust = clst;                          /* Update current cluster */

-                               fs->csect = 0;                                          /* Reset sector offset in the cluster */

                        }
                        sect = clust2sect(fs->curr_clust);              /* Get current sector */
                        }
                        sect = clust2sect(fs->curr_clust);              /* Get current sector */

-                       if (!sect) {
-                               fs->flag = 0; return FR_DISK_ERR;
-                       }
-                       sect += fs->csect;
-                       fs->dsect = sect;
-                       fs->csect++;                                                    /* Next sector address in the cluster */
+                       if (!sect) goto fr_abort;
+                       fs->dsect = sect + cs;

                }
                }

-               rcnt = 512 - ((WORD)fs->fptr % 512);            /* Get partial sector data from sector buffer */
+               rcnt = (WORD)(512 - (fs->fptr % 512));          /* Get partial sector data from sector buffer */

                if (rcnt > btr) rcnt = btr;
                if (rcnt > btr) rcnt = btr;

-               if (fs->flag & FA_STREAM) {
-                       dr = disk_readp(dest, fs->dsect, (WORD)(fs->fptr % 512), (WORD)(rcnt | 0x8000));
-               } else {
-                       dr = disk_readp(rbuff, fs->dsect, (WORD)(fs->fptr % 512), rcnt);
+               dr = disk_readp(!buff ? 0 : rbuff, fs->dsect, (WORD)(fs->fptr % 512), rcnt);
+               if (dr) goto fr_abort;
+               fs->fptr += rcnt; rbuff += rcnt;                        /* Update pointers and counters */
+               btr -= rcnt; *br += rcnt;
+       }
+
+       return FR_OK;
+
+fr_abort:
+       fs->flag = 0;
+       return FR_DISK_ERR;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write File                                                            */
+/*-----------------------------------------------------------------------*/
+#if _USE_WRITE
+
+FRESULT pf_write (
+       const void* buff,       /* Pointer to the data to be written */
+       WORD btw,                       /* Number of bytes to write (0:Finalize the current write operation) */
+       WORD* bw                        /* Pointer to number of bytes written */
+)
+{
+       CLUST clst;
+       DWORD sect, remain;
+       const BYTE *p = buff;
+       BYTE cs;
+       WORD wcnt;
+       FATFS *fs = FatFs;
+
+
+       *bw = 0;
+       if (!fs) return FR_NOT_ENABLED;         /* Check file system */
+       if (!(fs->flag & FA_OPENED))            /* Check if opened */
+               return FR_NOT_OPENED;
+
+       if (!btw) {             /* Finalize request */
+               if ((fs->flag & FA__WIP) && disk_writep(0, 0)) goto fw_abort;
+               fs->flag &= ~FA__WIP;
+               return FR_OK;
+       } else {                /* Write data request */
+               if (!(fs->flag & FA__WIP))              /* Round-down fptr to the sector boundary */
+                       fs->fptr &= 0xFFFFFE00;
+       }
+       remain = fs->fsize - fs->fptr;
+       if (btw > remain) btw = (WORD)remain;                   /* Truncate btw by remaining bytes */
+
+       while (btw)     {                                                                       /* Repeat until all data transferred */
+               if (((WORD)fs->fptr % 512) == 0) {                      /* On the sector boundary? */
+                       cs = (BYTE)(fs->fptr / 512 & (fs->csize - 1));  /* Sector offset in the cluster */
+                       if (!cs) {                                                              /* On the cluster boundary? */
+                               clst = (fs->fptr == 0) ?                        /* On the top of the file? */
+                                       fs->org_clust : get_fat(fs->curr_clust);
+                               if (clst <= 1) goto fw_abort;
+                               fs->curr_clust = clst;                          /* Update current cluster */
+                       }
+                       sect = clust2sect(fs->curr_clust);              /* Get current sector */
+                       if (!sect) goto fw_abort;
+                       fs->dsect = sect + cs;
+                       if (disk_writep(0, fs->dsect)) goto fw_abort;   /* Initiate a sector write operation */
+                       fs->flag |= FA__WIP;

                }
                }

-               if (dr) {
-                       fs->flag = 0;
-                       return (dr == RES_STRERR) ? FR_STREAM_ERR : FR_DISK_ERR;
+               wcnt = 512 - ((WORD)fs->fptr % 512);            /* Number of bytes to write to the sector */
+               if (wcnt > btw) wcnt = btw;
+               if (disk_writep(p, wcnt)) goto fw_abort;        /* Send data to the sector */
+               fs->fptr += wcnt; p += wcnt;                            /* Update pointers and counters */
+               btw -= wcnt; *bw += wcnt;
+               if (((WORD)fs->fptr % 512) == 0) {
+                       if (disk_writep(0, 0)) goto fw_abort;   /* Finalize the currtent secter write operation */
+                       fs->flag &= ~FA__WIP;

                }
        }
 
        return FR_OK;
                }
        }
 
        return FR_OK;

-}

 
 

+fw_abort:
+       fs->flag = 0;
+       return FR_DISK_ERR;
+}
+#endif

 
 
 
 
 
 

-#if _USE_LSEEK

 /*-----------------------------------------------------------------------*/
 /* Seek File R/W Pointer                                                 */
 /*-----------------------------------------------------------------------*/
 /*-----------------------------------------------------------------------*/
 /* Seek File R/W Pointer                                                 */
 /*-----------------------------------------------------------------------*/

+#if _USE_LSEEK

 
 FRESULT pf_lseek (
        DWORD ofs               /* File pointer from top of file */
 )
 {
        CLUST clst;
 
 FRESULT pf_lseek (
        DWORD ofs               /* File pointer from top of file */
 )
 {
        CLUST clst;

-       DWORD bcs, nsect, ifptr;
+       DWORD bcs, sect, ifptr;

        FATFS *fs = FatFs;
 
 
        if (!fs) return FR_NOT_ENABLED;         /* Check file system */
        FATFS *fs = FatFs;
 
 
        if (!fs) return FR_NOT_ENABLED;         /* Check file system */

-       if (!(fs->flag & FA_READ))
-                       return FR_INVALID_OBJECT;
+       if (!(fs->flag & FA_OPENED))            /* Check if opened */
+                       return FR_NOT_OPENED;

 
        if (ofs > fs->fsize) ofs = fs->fsize;   /* Clip offset with the file size */
        ifptr = fs->fptr;
 
        if (ofs > fs->fsize) ofs = fs->fsize;   /* Clip offset with the file size */
        ifptr = fs->fptr;


@@ -664,32 +1009,32 @@ FRESULT pf_lseek (
                        fs->curr_clust = clst;
                }
                while (ofs > bcs) {                             /* Cluster following loop */
                        fs->curr_clust = clst;
                }
                while (ofs > bcs) {                             /* Cluster following loop */

-                               clst = get_fat(clst);   /* Follow cluster chain if not in write mode */
-                       if (clst <= 1 || clst >= fs->max_clust) {
-                               fs->flag = 0; return FR_DISK_ERR;
-                       }
+                       clst = get_fat(clst);           /* Follow cluster chain */
+                       if (clst <= 1 || clst >= fs->n_fatent) goto fe_abort;

                        fs->curr_clust = clst;
                        fs->fptr += bcs;
                        ofs -= bcs;
                }
                fs->fptr += ofs;
                        fs->curr_clust = clst;
                        fs->fptr += bcs;
                        ofs -= bcs;
                }
                fs->fptr += ofs;

-               fs->csect = (BYTE)(ofs / 512) + 1;      /* Sector offset in the cluster */
-               nsect = clust2sect(clst);       /* Current sector */
-               if (!nsect) {
-                       fs->flag = 0; return FR_DISK_ERR;
-               }
-               fs->dsect = nsect + fs->csect - 1;
+               sect = clust2sect(clst);                /* Current sector */
+               if (!sect) goto fe_abort;
+               fs->dsect = sect + (fs->fptr / 512 & (fs->csize - 1));

        }
 
        return FR_OK;
        }
 
        return FR_OK;

+
+fe_abort:
+       fs->flag = 0;
+       return FR_DISK_ERR;

 }
 #endif
 
 
 }
 #endif
 
 

-#if _USE_DIR
+

 /*-----------------------------------------------------------------------*/
 /* Create a Directroy Object                                             */
 /*-----------------------------------------------------------------------*/
 /*-----------------------------------------------------------------------*/
 /* Create a Directroy Object                                             */
 /*-----------------------------------------------------------------------*/

+#if _USE_DIR

 
 FRESULT pf_opendir (
        DIR *dj,                        /* Pointer to directory object to create */
 
 FRESULT pf_opendir (
        DIR *dj,                        /* Pointer to directory object to create */


@@ -704,24 +1049,17 @@ FRESULT pf_opendir (
        if (!fs) {                              /* Check file system */
                res = FR_NOT_ENABLED;
        } else {
        if (!fs) {                              /* Check file system */
                res = FR_NOT_ENABLED;
        } else {

-               fs->buf = dir;

                dj->fn = sp;
                dj->fn = sp;

-               res = follow_path(dj, path);                    /* Follow the path to the directory */
+               res = follow_path(dj, dir, path);               /* Follow the path to the directory */

                if (res == FR_OK) {                                             /* Follow completed */
                        if (dir[0]) {                                           /* It is not the root dir */
                if (res == FR_OK) {                                             /* Follow completed */
                        if (dir[0]) {                                           /* It is not the root dir */

-                               if (dir[DIR_Attr] & AM_DIR) {   /* The object is a directory */
-                                       dj->sclust =
-#if _FS_FAT32
-                                       ((DWORD)LD_WORD(dir+DIR_FstClusHI) << 16) |
-#endif
-                                       LD_WORD(dir+DIR_FstClusLO);
-                               } else {                                                /* The object is not a directory */
+                               if (dir[DIR_Attr] & AM_DIR)             /* The object is a directory */
+                                       dj->sclust = LD_CLUST(dir);
+                               else                                                    /* The object is not a directory */

                                        res = FR_NO_PATH;
                                        res = FR_NO_PATH;

-                               }

                        }
                        }

-                       if (res == FR_OK) {
+                       if (res == FR_OK)

                                res = dir_rewind(dj);                   /* Rewind dir */
                                res = dir_rewind(dj);                   /* Rewind dir */

-                       }

                }
                if (res == FR_NO_FILE) res = FR_NO_PATH;
        }
                }
                if (res == FR_NO_FILE) res = FR_NO_PATH;
        }


@@ -749,18 +1087,17 @@ FRESULT pf_readdir (
        if (!fs) {                              /* Check file system */
                res = FR_NOT_ENABLED;
        } else {
        if (!fs) {                              /* Check file system */
                res = FR_NOT_ENABLED;
        } else {

-               fs->buf = dir;

                dj->fn = sp;
                if (!fno) {
                        res = dir_rewind(dj);
                } else {
                dj->fn = sp;
                if (!fno) {
                        res = dir_rewind(dj);
                } else {

-                       res = dir_read(dj);
+                       res = dir_read(dj, dir);

                        if (res == FR_NO_FILE) {
                                dj->sect = 0;
                                res = FR_OK;
                        }
                        if (res == FR_OK) {                             /* A valid entry is found */
                        if (res == FR_NO_FILE) {
                                dj->sect = 0;
                                res = FR_OK;
                        }
                        if (res == FR_OK) {                             /* A valid entry is found */

-                               get_fileinfo(dj, fno);          /* Get the object information */
+                               get_fileinfo(dj, dir, fno);     /* Get the object information */

                                res = dir_next(dj);                     /* Increment index for next */
                                if (res == FR_NO_FILE) {
                                        dj->sect = 0;
                                res = dir_next(dj);                     /* Increment index for next */
                                if (res == FR_NO_FILE) {
                                        dj->sect = 0;


@@ -773,5 +1110,5 @@ FRESULT pf_readdir (
        return res;
 }
 
        return res;
 }
 

-#endif /* _FS_DIR */
+#endif /* _USE_DIR */