hhhhhhhhh

Fork of FATFileSystem by mbed official

Files at this revision

API Documentation at this revision

Comitter:
mbed_official
Date:
Thu Aug 13 10:15:39 2015 +0100
Parent:
4:3ff2606d5713
Commit message:
Synchronized with git revision ab6a668ec18ad1530649c4cf1067a42816c6a7f8

Full URL: https://github.com/mbedmicro/mbed/commit/ab6a668ec18ad1530649c4cf1067a42816c6a7f8/

FATFileSystem - Updated FatFs to R0.11

Changed in this revision

ChaN/ccsbcs.cpp Show annotated file Show diff for this revision Revisions of this file
ChaN/diskio.cpp Show annotated file Show diff for this revision Revisions of this file
ChaN/diskio.h Show annotated file Show diff for this revision Revisions of this file
ChaN/ff.cpp Show annotated file Show diff for this revision Revisions of this file
ChaN/ff.h Show annotated file Show diff for this revision Revisions of this file
ChaN/ffconf.h Show annotated file Show diff for this revision Revisions of this file
ChaN/integer.h Show annotated file Show diff for this revision Revisions of this file
FATDirHandle.cpp Show annotated file Show diff for this revision Revisions of this file
FATFileSystem.cpp Show annotated file Show diff for this revision Revisions of this file
FATFileSystem.h Show annotated file Show diff for this revision Revisions of this file
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/ccsbcs.cpp
--- a/ChaN/ccsbcs.cpp	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/ccsbcs.cpp	Thu Aug 13 10:15:39 2015 +0100
@@ -1,5 +1,5 @@
 /*------------------------------------------------------------------------*/
-/* Unicode - Local code bidirectional converter  (C)ChaN, 2009            */
+/* Unicode - Local code bidirectional converter  (C)ChaN, 2012            */
 /* (SBCS code pages)                                                      */
 /*------------------------------------------------------------------------*/
 /*  437   U.S. (OEM)
@@ -31,463 +31,463 @@
 #if _CODE_PAGE == 437
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP437(0x80-0xFF) to Unicode conversion table */
-    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
-    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
-    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
-    0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
-    0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
-    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
-    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
-    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
-    0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
-    0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
-    0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP437(0x80-0xFF) to Unicode conversion table */
+	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+	0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+	0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+	0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+	0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+	0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+	0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+	0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+	0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 720
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP720(0x80-0xFF) to Unicode conversion table */
-    0x0000, 0x0000, 0x00E9, 0x00E2, 0x0000, 0x00E0, 0x0000, 0x00E7,
-    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x0651, 0x0652, 0x00F4, 0x00A4, 0x0640, 0x00FB, 0x00F9,
-    0x0621, 0x0622, 0x0623, 0x0624, 0x00A3, 0x0625, 0x0626, 0x0627,
-    0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
-    0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
-    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
-    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
-    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x00B5, 0x0642,
-    0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
-    0x2261, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0xO650, 0x2248,
-    0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP720(0x80-0xFF) to Unicode conversion table */
+	0x0000, 0x0000, 0x00E9, 0x00E2, 0x0000, 0x00E0, 0x0000, 0x00E7,
+	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x0651, 0x0652, 0x00F4, 0x00A4, 0x0640, 0x00FB, 0x00F9,
+	0x0621, 0x0622, 0x0623, 0x0624, 0x00A3, 0x0625, 0x0626, 0x0627,
+	0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
+	0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+	0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+	0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+	0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0641, 0x00B5, 0x0642,
+	0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
+	0x2261, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0x0650, 0x2248,
+	0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 737
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP737(0x80-0xFF) to Unicode conversion table */
-    0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
-    0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
-    0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
-    0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
-    0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
-    0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
-    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
-    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
-    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD,
-    0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
-    0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248,
-    0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP737(0x80-0xFF) to Unicode conversion table */
+	0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
+	0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
+	0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
+	0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
+	0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
+	0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+	0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+	0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+	0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD,
+	0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
+	0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248,
+	0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 775
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP775(0x80-0xFF) to Unicode conversion table */
-    0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107,
-    0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
-    0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A,
-    0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
-    0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6,
-    0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118,
-    0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
-    0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B,
-    0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144,
-    0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
-    0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E,
-    0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP775(0x80-0xFF) to Unicode conversion table */
+	0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107,
+	0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
+	0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A,
+	0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
+	0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6,
+	0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118,
+	0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
+	0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B,
+	0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144,
+	0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
+	0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E,
+	0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 850
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP850(0x80-0xFF) to Unicode conversion table */
-    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
-    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
-    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
-    0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
-    0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
-    0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
-    0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
-    0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
-    0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
-    0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
-    0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
-    0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP850(0x80-0xFF) to Unicode conversion table */
+	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+	0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+	0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+	0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+	0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
+	0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+	0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
+	0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+	0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+	0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 852
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP852(0x80-0xFF) to Unicode conversion table */
-    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7,
-    0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
-    0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A,
-    0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E,
-    0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A,
-    0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
-    0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE,
-    0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
-    0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161,
-    0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
-    0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
-    0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP852(0x80-0xFF) to Unicode conversion table */
+	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7,
+	0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
+	0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A,
+	0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E,
+	0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A,
+	0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+	0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE,
+	0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
+	0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161,
+	0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
+	0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
+	0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 855
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP855(0x80-0xFF) to Unicode conversion table */
-    0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404,
-    0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
-    0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C,
-    0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
-    0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414,
-    0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438,
-    0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
-    0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E,
-    0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
-    0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443,
-    0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
-    0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D,
-    0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP855(0x80-0xFF) to Unicode conversion table */
+	0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404,
+	0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
+	0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C,
+	0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
+	0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414,
+	0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438,
+	0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+	0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E,
+	0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
+	0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443,
+	0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
+	0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D,
+	0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 857
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP857(0x80-0xFF) to Unicode conversion table */
-    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
-    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
-    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
-    0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
-    0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
-    0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
-    0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0x0000, 0x00CD, 0x00CE,
-    0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
-    0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x0000,
-    0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
-    0x00AD, 0x00B1, 0x0000, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
-    0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP857(0x80-0xFF) to Unicode conversion table */
+	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
+	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+	0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
+	0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+	0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+	0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0x0000, 0x00CD, 0x00CE,
+	0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+	0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x0000,
+	0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
+	0x00AD, 0x00B1, 0x0000, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+	0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 858
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP858(0x80-0xFF) to Unicode conversion table */
-    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
-    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
-    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
-    0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
-    0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
-    0x00A9, 0x2563, 0x2551, 0x2557, 0x2550, 0x00A2, 0x00A5, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
-    0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x20AC, 0x00CD, 0x00CE,
-    0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00C6, 0x00CC, 0x2580,
-    0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
-    0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
-    0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
-    0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP858(0x80-0xFF) to Unicode conversion table */
+	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+	0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+	0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+	0x00A9, 0x2563, 0x2551, 0x2557, 0x2550, 0x00A2, 0x00A5, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+	0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x20AC, 0x00CD, 0x00CE,
+	0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00C6, 0x00CC, 0x2580,
+	0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
+	0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+	0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+	0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 862
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP862(0x80-0xFF) to Unicode conversion table */
-    0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
-    0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
-    0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
-    0x05E8, 0x05E9, 0x05EA, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
-    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
-    0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
-    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
-    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
-    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
-    0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
-    0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
-    0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP862(0x80-0xFF) to Unicode conversion table */
+	0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
+	0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
+	0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
+	0x05E8, 0x05E9, 0x05EA, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+	0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+	0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+	0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+	0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+	0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+	0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+	0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 866
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP866(0x80-0xFF) to Unicode conversion table */
-    0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
-    0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
-    0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
-    0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
-    0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
-    0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
-    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
-    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
-    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
-    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
-    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
-    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
-    0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
-    0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
-    0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
-    0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0
+const WCHAR Tbl[] = {	/*  CP866(0x80-0xFF) to Unicode conversion table */
+	0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
+	0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+	0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
+	0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+	0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+	0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+	0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+	0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+	0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+	0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+	0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+	0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+	0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+	0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+	0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
+	0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0
 };
 
 #elif _CODE_PAGE == 874
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP874(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x0000, 0x0000, 0x0000, 0x2026, 0x0000, 0x0000,
-    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
-    0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
-    0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
-    0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
-    0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
-    0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
-    0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
-    0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F,
-    0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
-    0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
-    0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
-    0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000
+const WCHAR Tbl[] = {	/*  CP874(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x0000, 0x0000, 0x0000, 0x2026, 0x0000, 0x0000,
+	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
+	0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
+	0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
+	0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
+	0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
+	0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
+	0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
+	0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F,
+	0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
+	0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
+	0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
+	0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000
 };
 
 #elif _CODE_PAGE == 1250
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1250(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x0000, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x0000, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
-    0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
-    0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
-    0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
-    0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
-    0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
-    0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
-    0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
-    0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
-    0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
-    0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
+const WCHAR Tbl[] = {	/*  CP1250(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x0000, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x0000, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
+	0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
+	0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
+	0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
+	0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
+	0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
+	0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
+	0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
+	0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
+	0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
+	0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
 };
 
 #elif _CODE_PAGE == 1251
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1251(0x80-0xFF) to Unicode conversion table */
-    0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
-    0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x0000, 0x2111, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
-    0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
-    0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
-    0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
-    0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
-    0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
-    0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
-    0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
-    0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
-    0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
-    0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
-    0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
-    0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F
+const WCHAR Tbl[] = {	/*  CP1251(0x80-0xFF) to Unicode conversion table */
+	0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
+	0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x0000, 0x2111, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
+	0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
+	0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+	0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
+	0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+	0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
+	0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+	0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
+	0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+	0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+	0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+	0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+	0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F
 };
 
 #elif _CODE_PAGE == 1252
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1252(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017D, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x017E, 0x0178,
-    0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-    0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
-    0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
-    0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
-    0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
-    0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
-    0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
-    0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
-    0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
+const WCHAR Tbl[] = {	/*  CP1252(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017D, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x017E, 0x0178,
+	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+	0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+	0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+	0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+	0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
+	0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+	0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+	0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+	0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
 };
 
 #elif _CODE_PAGE == 1253
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1253(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x0000, 0x2030, 0x0000, 0x2039, 0x000C, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x0000, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
-    0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
-    0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
-    0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
-    0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
-    0x03A8, 0x03A9, 0x03AA, 0x03AD, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
-    0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
-    0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
-    0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
-    0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000
+const WCHAR Tbl[] = {	/*  CP1253(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x0000, 0x2030, 0x0000, 0x2039, 0x000C, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x0000, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
+	0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
+	0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+	0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
+	0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
+	0x03A8, 0x03A9, 0x03AA, 0x03AD, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
+	0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
+	0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
+	0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
+	0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000
 };
 
 #elif _CODE_PAGE == 1254
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1254(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x210A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
-    0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-    0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
-    0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
-    0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
-    0x00D8, 0x00D9, 0x00DA, 0x00BD, 0x00DC, 0x0130, 0x015E, 0x00DF,
-    0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
-    0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
-    0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
-    0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
+const WCHAR Tbl[] = {	/*  CP1254(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x210A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
+	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+	0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+	0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+	0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+	0x00D8, 0x00D9, 0x00DA, 0x00BD, 0x00DC, 0x0130, 0x015E, 0x00DF,
+	0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+	0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+	0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+	0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
 };
 
 #elif _CODE_PAGE == 1255
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1255(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x02C6, 0x2030, 0x0000, 0x2039, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x02DC, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-    0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
-    0x05B8, 0x05B9, 0x0000, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
-    0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
-    0x05F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
-    0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
-    0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
-    0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000
+const WCHAR Tbl[] = {	/*  CP1255(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x02C6, 0x2030, 0x0000, 0x2039, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x02DC, 0x2122, 0x0000, 0x203A, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+	0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
+	0x05B8, 0x05B9, 0x0000, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
+	0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
+	0x05F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+	0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
+	0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
+	0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
+	0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000
 };
 
 #elif _CODE_PAGE == 1256
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1256(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
-    0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
-    0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
-    0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
-    0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
-    0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
-    0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0640, 0x0642, 0x0643,
-    0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
-    0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
-    0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
-    0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2
-}
+const WCHAR Tbl[] = {	/*  CP1256(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
+	0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
+	0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
+	0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+	0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
+	0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
+	0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0640, 0x0642, 0x0643,
+	0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
+	0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
+	0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
+	0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2
+};
 
 #elif _CODE_PAGE == 1257
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1257(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x0000, 0x2030, 0x0000, 0x2039, 0x0000, 0x00A8, 0x02C7, 0x00B8,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x00AF, 0x02DB, 0x0000,
-    0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x0000, 0x00A6, 0x00A7,
-    0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
-    0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
-    0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
-    0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
-    0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
-    0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
-    0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
-    0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
-    0x0173, 0x014E, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9
+const WCHAR Tbl[] = {	/*  CP1257(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0000, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x0000, 0x2030, 0x0000, 0x2039, 0x0000, 0x00A8, 0x02C7, 0x00B8,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x0000, 0x2122, 0x0000, 0x203A, 0x0000, 0x00AF, 0x02DB, 0x0000,
+	0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x0000, 0x00A6, 0x00A7,
+	0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
+	0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
+	0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
+	0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
+	0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
+	0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
+	0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
+	0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
+	0x0173, 0x014E, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9
 };
 
 #elif _CODE_PAGE == 1258
 #define _TBLDEF 1
 static
-const WCHAR Tbl[] = {   /*  CP1258(0x80-0xFF) to Unicode conversion table */
-    0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-    0x02C6, 0x2030, 0x0000, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-    0x02DC, 0x2122, 0x0000, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
-    0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-    0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-    0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-    0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
-    0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
-    0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
-    0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
-    0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
-    0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
-    0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
-    0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF
+const WCHAR Tbl[] = {	/*  CP1258(0x80-0xFF) to Unicode conversion table */
+	0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+	0x02C6, 0x2030, 0x0000, 0x2039, 0x0152, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+	0x02DC, 0x2122, 0x0000, 0x203A, 0x0153, 0x0000, 0x0000, 0x0178,
+	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+	0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+	0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+	0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+	0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
+	0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
+	0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
+	0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+	0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
+	0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
+	0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF
 };
 
 #endif
@@ -498,43 +498,44 @@
 #endif
 
 
-WCHAR ff_convert (  /* Converted character, Returns zero on error */
-    WCHAR   src,    /* Character code to be converted */
-    UINT    dir     /* 0: Unicode to OEMCP, 1: OEMCP to Unicode */
+WCHAR ff_convert (	/* Converted character, Returns zero on error */
+	WCHAR	chr,	/* Character code to be converted */
+	UINT	dir		/* 0: Unicode to OEMCP, 1: OEMCP to Unicode */
 )
 {
-    WCHAR c;
+	WCHAR c;
 
 
-    if (src < 0x80) {   /* ASCII */
-        c = src;
+	if (chr < 0x80) {	/* ASCII */
+		c = chr;
 
-    } else {
-        if (dir) {      /* OEMCP to Unicode */
-            c = (src >= 0x100) ? 0 : Tbl[src - 0x80];
+	} else {
+		if (dir) {		/* OEMCP to Unicode */
+			c = (chr >= 0x100) ? 0 : Tbl[chr - 0x80];
 
-        } else {        /* Unicode to OEMCP */
-            for (c = 0; c < 0x80; c++) {
-                if (src == Tbl[c]) break;
-            }
-            c = (c + 0x80) & 0xFF;
-        }
-    }
+		} else {		/* Unicode to OEMCP */
+			for (c = 0; c < 0x80; c++) {
+				if (chr == Tbl[c]) break;
+			}
+			c = (c + 0x80) & 0xFF;
+		}
+	}
 
-    return c;
+	return c;
 }
 
 
-WCHAR ff_wtoupper ( /* Upper converted character */
-    WCHAR chr       /* Input character */
+WCHAR ff_wtoupper (	/* Upper converted character */
+	WCHAR chr		/* Input character */
 )
 {
-    static const WCHAR tbl_lower[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0x00A2, 0x00A3, 0x00A5, 0x00AC, 0x00AF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x0FF, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x148, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x192, 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF, 0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7, 0x3C8, 0x3C9, 0x3CA, 0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x45E, 0x45F, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0 };
-    static const WCHAR tbl_upper[] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x21, 0xFFE0, 0xFFE1, 0xFFE5, 0xFFE2, 0xFFE3, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x178, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x179, 0x17B, 0x17D, 0x191, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, 0x3A0, 0x3A1, 0x3A3, 0x3A4, 0x3A5, 0x3A6, 0x3A7, 0x3A8, 0x3A9, 0x3AA, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B, 0x42C, 0x42D, 0x42E, 0x42F, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40E, 0x40F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0 };
-    int i;
+	static const WCHAR tbl_lower[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0x00A2, 0x00A3, 0x00A5, 0x00AC, 0x00AF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x0FF, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10B, 0x10D, 0x10F, 0x111, 0x113, 0x115, 0x117, 0x119, 0x11B, 0x11D, 0x11F, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12B, 0x12D, 0x12F, 0x131, 0x133, 0x135, 0x137, 0x13A, 0x13C, 0x13E, 0x140, 0x142, 0x144, 0x146, 0x148, 0x14B, 0x14D, 0x14F, 0x151, 0x153, 0x155, 0x157, 0x159, 0x15B, 0x15D, 0x15F, 0x161, 0x163, 0x165, 0x167, 0x169, 0x16B, 0x16D, 0x16F, 0x171, 0x173, 0x175, 0x177, 0x17A, 0x17C, 0x17E, 0x192, 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF, 0x3C0, 0x3C1, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7, 0x3C8, 0x3C9, 0x3CA, 0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44C, 0x44D, 0x44E, 0x44F, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x45E, 0x45F, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0 };
+	static const WCHAR tbl_upper[] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x21, 0xFFE0, 0xFFE1, 0xFFE5, 0xFFE2, 0xFFE3, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0x178, 0x100, 0x102, 0x104, 0x106, 0x108, 0x10A, 0x10C, 0x10E, 0x110, 0x112, 0x114, 0x116, 0x118, 0x11A, 0x11C, 0x11E, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x132, 0x134, 0x136, 0x139, 0x13B, 0x13D, 0x13F, 0x141, 0x143, 0x145, 0x147, 0x14A, 0x14C, 0x14E, 0x150, 0x152, 0x154, 0x156, 0x158, 0x15A, 0x15C, 0x15E, 0x160, 0x162, 0x164, 0x166, 0x168, 0x16A, 0x16C, 0x16E, 0x170, 0x172, 0x174, 0x176, 0x179, 0x17B, 0x17D, 0x191, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x39B, 0x39C, 0x39D, 0x39E, 0x39F, 0x3A0, 0x3A1, 0x3A3, 0x3A4, 0x3A5, 0x3A6, 0x3A7, 0x3A8, 0x3A9, 0x3AA, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42A, 0x42B, 0x42C, 0x42D, 0x42E, 0x42F, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40E, 0x40F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0 };
+	int i;
 
 
-    for (i = 0; tbl_lower[i] && chr != tbl_lower[i]; i++) ;
+	for (i = 0; tbl_lower[i] && chr != tbl_lower[i]; i++) ;
 
-    return tbl_lower[i] ? tbl_upper[i] : chr;
+	return tbl_lower[i] ? tbl_upper[i] : chr;
 }
+
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/diskio.cpp
--- a/ChaN/diskio.cpp	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/diskio.cpp	Thu Aug 13 10:15:39 2015 +0100
@@ -13,30 +13,30 @@
 using namespace mbed;
 
 DSTATUS disk_initialize (
-    BYTE drv                /* Physical drive nmuber (0..) */
+    BYTE pdrv        /* Physical drive number (0..) */
 )
 {
-    debug_if(FFS_DBG, "disk_initialize on drv [%d]\n", drv);
-    return (DSTATUS)FATFileSystem::_ffs[drv]->disk_initialize();
+    debug_if(FFS_DBG, "disk_initialize on pdrv [%d]\n", pdrv);
+    return (DSTATUS)FATFileSystem::_ffs[pdrv]->disk_initialize();
 }
 
 DSTATUS disk_status (
-    BYTE drv        /* Physical drive nmuber (0..) */
+    BYTE pdrv        /* Physical drive number (0..) */
 )
 {
-    debug_if(FFS_DBG, "disk_status on drv [%d]\n", drv);
-    return (DSTATUS)FATFileSystem::_ffs[drv]->disk_status();
+    debug_if(FFS_DBG, "disk_status on pdrv [%d]\n", pdrv);
+    return (DSTATUS)FATFileSystem::_ffs[pdrv]->disk_status();
 }
 
 DRESULT disk_read (
-    BYTE drv,        /* Physical drive nmuber (0..) */
-    BYTE *buff,        /* Data buffer to store read data */
+    BYTE pdrv,       /* Physical drive number (0..) */
+    BYTE* buff,      /* Data buffer to store read data */
     DWORD sector,    /* Sector address (LBA) */
-    BYTE count        /* Number of sectors to read (1..255) */
+    UINT count       /* Number of sectors to read (1..) */
 )
 {
-    debug_if(FFS_DBG, "disk_read(sector %d, count %d) on drv [%d]\n", sector, count, drv);
-    if (FATFileSystem::_ffs[drv]->disk_read((uint8_t*)buff, sector, count))
+    debug_if(FFS_DBG, "disk_read(sector %d, count %d) on pdrv [%d]\n", sector, count, pdrv);
+    if (FATFileSystem::_ffs[pdrv]->disk_read((uint8_t*)buff, sector, count))
         return RES_PARERR;
     else
         return RES_OK;
@@ -44,14 +44,14 @@
 
 #if _READONLY == 0
 DRESULT disk_write (
-    BYTE drv,            /* Physical drive nmuber (0..) */
-    const BYTE *buff,    /* Data to be written */
+    BYTE pdrv,           /* Physical drive number (0..) */
+    const BYTE* buff,    /* Data to be written */
     DWORD sector,        /* Sector address (LBA) */
-    BYTE count            /* Number of sectors to write (1..255) */
+    UINT count           /* Number of sectors to write (1..) */
 )
 {
-    debug_if(FFS_DBG, "disk_write(sector %d, count %d) on drv [%d]\n", sector, count, drv);
-    if (FATFileSystem::_ffs[drv]->disk_write((uint8_t*)buff, sector, count))
+    debug_if(FFS_DBG, "disk_write(sector %d, count %d) on pdrv [%d]\n", sector, count, pdrv);
+    if (FATFileSystem::_ffs[pdrv]->disk_write((uint8_t*)buff, sector, count))
         return RES_PARERR;
     else
         return RES_OK;
@@ -59,25 +59,25 @@
 #endif /* _READONLY */
 
 DRESULT disk_ioctl (
-    BYTE drv,        /* Physical drive nmuber (0..) */
-    BYTE ctrl,        /* Control code */
-    void *buff        /* Buffer to send/receive control data */
+    BYTE pdrv,        /* Physical drive number (0..) */
+    BYTE cmd,         /* Control code */
+    void* buff        /* Buffer to send/receive control data */
 )
 {
-    debug_if(FFS_DBG, "disk_ioctl(%d)\n", ctrl);
-    switch(ctrl) {
+    debug_if(FFS_DBG, "disk_ioctl(%d)\n", cmd);
+    switch(cmd) {
         case CTRL_SYNC:
-            if(FATFileSystem::_ffs[drv] == NULL) {
+            if(FATFileSystem::_ffs[pdrv] == NULL) {
                 return RES_NOTRDY;
-            } else if(FATFileSystem::_ffs[drv]->disk_sync()) {
+            } else if(FATFileSystem::_ffs[pdrv]->disk_sync()) {
                 return RES_ERROR;
             }
             return RES_OK;
         case GET_SECTOR_COUNT:
-            if(FATFileSystem::_ffs[drv] == NULL) {
+            if(FATFileSystem::_ffs[pdrv] == NULL) {
                 return RES_NOTRDY;
             } else {
-                DWORD res = FATFileSystem::_ffs[drv]->disk_sectors();
+                DWORD res = FATFileSystem::_ffs[pdrv]->disk_sectors();
                 if(res > 0) {
                     *((DWORD*)buff) = res; // minimum allowed
                     return RES_OK;
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/diskio.h
--- a/ChaN/diskio.h	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/diskio.h	Thu Aug 13 10:15:39 2015 +0100
@@ -1,76 +1,81 @@
-//-----------------------------------------------------------------------
-//  Low level disk interface modlue include file
-//-----------------------------------------------------------------------
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2014          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
 
-#ifndef _DISKIO
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-#define _READONLY    0   // 1: Remove write functions
-#define _USE_IOCTL   1   // 1: Use disk_ioctl fucntion
+#define _USE_WRITE	1	/* 1: Enable disk_write function */
+#define _USE_IOCTL	1	/* 1: Enable disk_ioctl fucntion */
 
 #include "integer.h"
 
 
-// Status of Disk Functions
-typedef BYTE    DSTATUS;
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
 
-// Results of Disk Functions
+/* 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
+	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
-
-int assign_drives (int, int);
-DSTATUS disk_initialize (BYTE);
-DSTATUS disk_status (BYTE);
-DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
-#if    _READONLY == 0
-DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
-#endif
-DRESULT disk_ioctl (BYTE, BYTE, void*);
+/*---------------------------------------*/
+/* 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
+
+/* 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
+/* Command code for disk_ioctrl fucntion */
 
-// Generic command (defined for FatFs)
-#define CTRL_SYNC           0    // Flush disk cache (for write functions)
-#define GET_SECTOR_COUNT    1    // Get media size (for only f_mkfs())
-#define GET_SECTOR_SIZE     2    // Get sector size (for multiple sector size (_MAX_SS >= 1024))
-#define GET_BLOCK_SIZE      3    // Get erase block size (for only f_mkfs())
-#define CTRL_ERASE_SECTOR   4    // Force erased a block of sectors (for only _USE_ERASE)
+/* 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
-#define CTRL_POWER          5    // Get/Set power status
-#define CTRL_LOCK           6    // Lock/Unlock media removal
-#define CTRL_EJECT          7    // Eject media
+/* 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
+/* 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 */
 
-// 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
+/* 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 */
 
-// NAND specific ioctl command
-#define NAND_FORMAT         30    // Create physical format
+#ifdef __cplusplus
+}
+#endif
 
+#endif
 
-#define _DISKIO
-#endif
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/ff.cpp
--- a/ChaN/ff.cpp	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/ff.cpp	Thu Aug 13 10:15:39 2015 +0100
@@ -1,102 +1,23 @@
 /*----------------------------------------------------------------------------/
-/  FatFs - FAT file system module  R0.09a                 (C)ChaN, 2012
+/  FatFs - FAT file system module  R0.11                 (C)ChaN, 2015
 /-----------------------------------------------------------------------------/
-/ FatFs module is a generic FAT file system module for small embedded systems.
-/ This is a free software that opened for education, research and commercial
-/ developments under license policy of following terms.
-/
-/  Copyright (C) 2012, ChaN, all right reserved.
-/
-/ * The FatFs module is a free software and there is NO WARRANTY.
-/ * No restriction on use. You can use, modify and redistribute it for
-/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.
-/ * Redistributions of source code must retain the above copyright notice.
-/
-/-----------------------------------------------------------------------------/
-/ Feb 26,'06 R0.00  Prototype.
-/
-/ Apr 29,'06 R0.01  First stable version.
-/
-/ Jun 01,'06 R0.02  Added FAT12 support.
-/                   Removed unbuffered mode.
-/                   Fixed a problem on small (<32M) partition.
-/ Jun 10,'06 R0.02a Added a configuration option (_FS_MINIMUM).
+/ FatFs module is a free software that opened under license policy of
+/ following conditions.
 /
-/ Sep 22,'06 R0.03  Added f_rename().
-/                   Changed option _FS_MINIMUM to _FS_MINIMIZE.
-/ Dec 11,'06 R0.03a Improved cluster scan algorithm to write files fast.
-/                   Fixed f_mkdir() creates incorrect directory on FAT32.
-/
-/ Feb 04,'07 R0.04  Supported multiple drive system.
-/                   Changed some interfaces for multiple drive system.
-/                   Changed f_mountdrv() to f_mount().
-/                   Added f_mkfs().
-/ Apr 01,'07 R0.04a 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().
-/ May 05,'07 R0.04b 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.
-/
-/ Aug 25,'07 R0.05  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.
-/ Feb 03,'08 R0.05a 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.
+/ Copyright (C) 2015, ChaN, all right reserved.
 /
-/ Apr 01,'08 R0.06  Added fputc(), fputs(), fprintf() and fgets().
-/                   Improved performance of f_lseek() on moving to the same or following cluster.
-/
-/ Apr 01,'09 R0.07  Merged Tiny-FatFs as a configuration option. (_FS_TINY)
-/                   Added long file name feature.
-/                   Added multiple code page feature.
-/                   Added re-entrancy for multitask operation.
-/                   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.
-/ Apr 14,'09 R0.07a Separated out OS dependent code on reentrant cfg.
-/                   Added multiple sector size feature.
-/ Jun 21,'09 R0.07c 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 char.
-/ Nov 03,'09 R0.07e Separated out configuration options from ff.h to ffconf.h.
-/                   Fixed f_unlink() fails to remove a sub-dir on _FS_RPATH.
-/                   Fixed name matching error on the 13 char boundary.
-/                   Added a configuration option, _LFN_UNICODE.
-/                   Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
 /
-/ May 15,'10 R0.08  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 member in the FILINFO structure on Unicode cfg.
-/                   String functions support UTF-8 encoding files on Unicode cfg.
-/ Aug 16,'10 R0.08a Added f_getcwd(). (_FS_RPATH = 2)
-/                   Added sector erase feature. (_USE_ERASE)
-/                   Moved file lock semaphore table from fs object to the bss.
-/                   Fixed a wrong directory entry is created on non-LFN cfg when the given name contains ';'.
-/                   Fixed f_mkfs() creates wrong FAT32 volume.
-/ Jan 15,'11 R0.08b 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 function.
-/                   Ignores duplicated directory separators in given path name.
-/
-/ Sep 06,'11 R0.09  f_mkfs() supports multiple partition to finish the multiple partition feature.
-/                   Added f_fdisk(). (_MULTI_PARTITION = 2)
-/ Aug 27,'12 R0.09a Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
-/                   Changed f_open() and f_opendir reject null object pointer to avoid crash.
-/                   Changed option name _FS_SHARE to _FS_LOCK.
-/---------------------------------------------------------------------------*/
-
-#include "ff.h"         /* FatFs configurations and declarations */
-#include "diskio.h"     /* Declarations of low level disk I/O functions */
+/ 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 disk I/O functions */
 
 
 /*--------------------------------------------------------------------------
@@ -105,242 +26,253 @@
 
 ---------------------------------------------------------------------------*/
 
-#if _FATFS != 4004  /* Revision ID */
+#if _FATFS != 32020	/* Revision ID */
 #error Wrong include file (ff.h).
 #endif
 
 
-/* Definitions on sector size */
-#if _MAX_SS != 512 && _MAX_SS != 1024 && _MAX_SS != 2048 && _MAX_SS != 4096
-#error Wrong sector size.
-#endif
-#if _MAX_SS != 512
-#define SS(fs)  ((fs)->ssize)   /* Variable sector size */
-#else
-#define SS(fs)  512U            /* Fixed sector size */
-#endif
-
-
 /* Reentrancy related */
 #if _FS_REENTRANT
 #if _USE_LFN == 1
-#error Static LFN work area must not be used in re-entrant configuration.
+#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; }
+#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
+#define	ENTER_FF(fs)
+#define LEAVE_FF(fs, res)	return res
+#endif
+
+#define	ABORT(fs, res)		{ fp->err = (BYTE)(res); LEAVE_FF(fs, res); }
+
+
+/* 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
-
-#define ABORT(fs, res)      { fp->flag |= FA__ERROR; LEAVE_FF(fs, res); }
+#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 feature */
+#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 access control feature */
 #if _FS_LOCK
 #if _FS_READONLY
-#error _FS_LOCK must be 0 on read-only cfg.
+#error _FS_LOCK must be 0 at read-only configuration
 #endif
 typedef struct {
-    FATFS *fs;              /* File ID 1, volume (NULL:blank entry) */
-    DWORD clu;              /* File ID 2, directory */
-    WORD idx;               /* File ID 3, directory index */
-    WORD ctr;               /* File open counter, 0:none, 0x01..0xFF:read open count, 0x100:write mode */
+	FATFS *fs;		/* Object ID 1, volume (NULL:blank entry) */
+	DWORD clu;		/* Object ID 2, directory (0:root) */
+	WORD idx;		/* Object ID 3, directory index */
+	WORD ctr;		/* Object open counter, 0:none, 0x01..0xFF:read mode open count, 0x100:write mode */
 } FILESEM;
 #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
+/* DBCS code ranges and SBCS extend character 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
+				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
+				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
+				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
+				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
+				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
+				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
+				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
+				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
+				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
+				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
+				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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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}
+				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 _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) */
+				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) */
 #if _USE_LFN
 #error Cannot use LFN feature without valid code page.
 #endif
-#define _DF1S   0
+#define _DF1S	0
 
 #else
 #error Unknown code page
@@ -349,168 +281,168 @@
 
 
 /* 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       /* 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)
+#define IsUpper(c)	(((c)>='A')&&((c)<='Z'))
+#define IsLower(c)	(((c)>='a')&&((c)<='z'))
+#define IsDigit(c)	(((c)>='0')&&((c)<='9'))
+
+#if _DF1S		/* 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))
+#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
+#else			/* Code page is SBCS */
+
+#define IsDBCS1(c)	0
+#define IsDBCS2(c)	0
 
 #endif /* _DF1S */
 
 
 /* Name status flags */
-#define NS          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 */
-
-
-/* FAT sub-type boundaries */
-/* Note that the FAT spec by Microsoft says 4085 but Windows works with 4087! */
-#define MIN_FAT16   4086    /* Minimum number of clusters for FAT16 */
-#define MIN_FAT32   65526   /* Minimum number of clusters for FAT32 */
+#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 */
+
+
+/* FAT sub-type boundaries (Differ from specs but correct for real DOS/Windows) */
+#define MIN_FAT16	4086U	/* Minimum number of clusters as FAT16 */
+#define	MIN_FAT32	65526U	/* Minimum number of clusters as FAT32 */
 
 
 /* FatFs refers the members in the FAT structures as byte array instead of
 / structure member because the structure is not binary compatible between
 / different platforms */
 
-#define BS_jmpBoot          0   /* Jump instruction (3) */
-#define BS_OEMName          3   /* OEM name (8) */
-#define BPB_BytsPerSec      11  /* Sector size [byte] (2) */
-#define BPB_SecPerClus      13  /* Cluster size [sector] (1) */
-#define BPB_RsvdSecCnt      14  /* Size of reserved area [sector] (2) */
-#define BPB_NumFATs         16  /* Number of FAT copies (1) */
-#define BPB_RootEntCnt      17  /* Number of root dir entries for FAT12/16 (2) */
-#define BPB_TotSec16        19  /* Volume size [sector] (2) */
-#define BPB_Media           21  /* Media descriptor (1) */
-#define BPB_FATSz16         22  /* FAT size [sector] (2) */
-#define BPB_SecPerTrk       24  /* Track size [sector] (2) */
-#define BPB_NumHeads        26  /* Number of heads (2) */
-#define BPB_HiddSec         28  /* Number of special hidden sectors (4) */
-#define BPB_TotSec32        32  /* Volume size [sector] (4) */
-#define BS_DrvNum           36  /* Physical drive number (2) */
-#define BS_BootSig          38  /* Extended boot signature (1) */
-#define BS_VolID            39  /* Volume serial number (4) */
-#define BS_VolLab           43  /* Volume label (8) */
-#define BS_FilSysType       54  /* File system type (1) */
-#define BPB_FATSz32         36  /* FAT size [sector] (4) */
-#define BPB_ExtFlags        40  /* Extended flags (2) */
-#define BPB_FSVer           42  /* File system version (2) */
-#define BPB_RootClus        44  /* Root dir first cluster (4) */
-#define BPB_FSInfo          48  /* Offset of FSInfo sector (2) */
-#define BPB_BkBootSec       50  /* Offset of backup boot sector (2) */
-#define BS_DrvNum32         64  /* Physical drive number (2) */
-#define BS_BootSig32        66  /* Extended boot signature (1) */
-#define BS_VolID32          67  /* Volume serial number (4) */
-#define BS_VolLab32         71  /* Volume label (8) */
-#define BS_FilSysType32     82  /* File system type (1) */
-#define FSI_LeadSig         0   /* FSI: Leading signature (4) */
-#define FSI_StrucSig        484 /* FSI: Structure signature (4) */
-#define FSI_Free_Count      488 /* FSI: Number of free clusters (4) */
-#define FSI_Nxt_Free        492 /* FSI: Last allocated cluster (4) */
-#define MBR_Table           446 /* MBR: Partition table offset (2) */
-#define SZ_PTE              16  /* MBR: Size of a partition table entry */
-#define BS_55AA             510 /* Boot sector signature (2) */
-
-#define DIR_Name            0   /* Short file name (11) */
-#define DIR_Attr            11  /* Attribute (1) */
-#define DIR_NTres           12  /* NT flag (1) */
-#define DIR_CrtTimeTenth    13  /* Created time sub-second (1) */
-#define DIR_CrtTime         14  /* Created time (2) */
-#define DIR_CrtDate         16  /* Created date (2) */
-#define DIR_LstAccDate      18  /* Last accessed date (2) */
-#define DIR_FstClusHI       20  /* Higher 16-bit of first cluster (2) */
-#define DIR_WrtTime         22  /* Modified time (2) */
-#define DIR_WrtDate         24  /* Modified date (2) */
-#define DIR_FstClusLO       26  /* Lower 16-bit of first cluster (2) */
-#define DIR_FileSize        28  /* File size (4) */
-#define LDIR_Ord            0   /* LFN entry order and LLE flag (1) */
-#define LDIR_Attr           11  /* LFN attribute (1) */
-#define LDIR_Type           12  /* LFN type (1) */
-#define LDIR_Chksum         13  /* Sum of corresponding SFN entry */
-#define LDIR_FstClusLO      26  /* Filled by zero (0) */
-#define SZ_DIR              32      /* Size of a directory entry */
-#define LLE                 0x40    /* Last long entry flag in LDIR_Ord */
-#define DDE                 0xE5    /* Deleted directory entry mark in DIR_Name[0] */
-#define NDDE                0x05    /* Replacement of the character collides with DDE */
+#define BS_jmpBoot			0		/* x86 jump instruction (3) */
+#define BS_OEMName			3		/* OEM name (8) */
+#define BPB_BytsPerSec		11		/* Sector size [byte] (2) */
+#define BPB_SecPerClus		13		/* Cluster size [sector] (1) */
+#define BPB_RsvdSecCnt		14		/* Size of reserved area [sector] (2) */
+#define BPB_NumFATs			16		/* Number of FAT copies (1) */
+#define BPB_RootEntCnt		17		/* Number of root directory entries for FAT12/16 (2) */
+#define BPB_TotSec16		19		/* Volume size [sector] (2) */
+#define BPB_Media			21		/* Media descriptor (1) */
+#define BPB_FATSz16			22		/* FAT size [sector] (2) */
+#define BPB_SecPerTrk		24		/* Track size [sector] (2) */
+#define BPB_NumHeads		26		/* Number of heads (2) */
+#define BPB_HiddSec			28		/* Number of special hidden sectors (4) */
+#define BPB_TotSec32		32		/* Volume size [sector] (4) */
+#define BS_DrvNum			36		/* Physical drive number (2) */
+#define BS_BootSig			38		/* Extended boot signature (1) */
+#define BS_VolID			39		/* Volume serial number (4) */
+#define BS_VolLab			43		/* Volume label (8) */
+#define BS_FilSysType		54		/* File system type (1) */
+#define BPB_FATSz32			36		/* FAT size [sector] (4) */
+#define BPB_ExtFlags		40		/* Extended flags (2) */
+#define BPB_FSVer			42		/* File system version (2) */
+#define BPB_RootClus		44		/* Root directory first cluster (4) */
+#define BPB_FSInfo			48		/* Offset of FSINFO sector (2) */
+#define BPB_BkBootSec		50		/* Offset of backup boot sector (2) */
+#define BS_DrvNum32			64		/* Physical drive number (2) */
+#define BS_BootSig32		66		/* Extended boot signature (1) */
+#define BS_VolID32			67		/* Volume serial number (4) */
+#define BS_VolLab32			71		/* Volume label (8) */
+#define BS_FilSysType32		82		/* File system type (1) */
+#define	FSI_LeadSig			0		/* FSI: Leading signature (4) */
+#define	FSI_StrucSig		484		/* FSI: Structure signature (4) */
+#define	FSI_Free_Count		488		/* FSI: Number of free clusters (4) */
+#define	FSI_Nxt_Free		492		/* FSI: Last allocated cluster (4) */
+#define MBR_Table			446		/* MBR: Partition table offset (2) */
+#define	SZ_PTE				16		/* MBR: Size of a partition table entry */
+#define BS_55AA				510		/* Signature word (2) */
+
+#define	DIR_Name			0		/* Short file name (11) */
+#define	DIR_Attr			11		/* Attribute (1) */
+#define	DIR_NTres			12		/* Lower case flag (1) */
+#define DIR_CrtTimeTenth	13		/* Created time sub-second (1) */
+#define	DIR_CrtTime			14		/* Created time (2) */
+#define	DIR_CrtDate			16		/* Created date (2) */
+#define DIR_LstAccDate		18		/* Last accessed date (2) */
+#define	DIR_FstClusHI		20		/* Higher 16-bit of first cluster (2) */
+#define	DIR_WrtTime			22		/* Modified time (2) */
+#define	DIR_WrtDate			24		/* Modified date (2) */
+#define	DIR_FstClusLO		26		/* Lower 16-bit of first cluster (2) */
+#define	DIR_FileSize		28		/* File size (4) */
+#define	LDIR_Ord			0		/* LFN entry order and LLE flag (1) */
+#define	LDIR_Attr			11		/* LFN attribute (1) */
+#define	LDIR_Type			12		/* LFN type (1) */
+#define	LDIR_Chksum			13		/* Sum of corresponding SFN entry */
+#define	LDIR_FstClusLO		26		/* Must be zero (0) */
+#define	SZ_DIRE				32		/* Size of a directory entry */
+#define	LLEF				0x40	/* Last long entry flag in LDIR_Ord */
+#define	DDEM				0xE5	/* Deleted directory entry mark at DIR_Name[0] */
+#define	RDDEM				0x05	/* Replacement of the character collides with DDEM */
+
+
 
 
 /*------------------------------------------------------------*/
 /* Module private work area                                   */
 /*------------------------------------------------------------*/
-/* Note that uninitialized variables with static duration are
-/  zeroed/nulled at start-up. If not, the compiler or start-up
-/  routine is out of ANSI-C standard.
+/* Remark: Uninitialized variables with static duration are
+/  guaranteed zero/null at start-up. If not, either the linker
+/  or start-up routine being used is out of ANSI-C standard.
 */
 
-#if _VOLUMES
-static
-FATFS *FatFs[_VOLUMES]; /* Pointer to the file system objects (logical drives) */
-#else
-#error Number of volumes must not be 0.
+#if _VOLUMES < 1 || _VOLUMES > 9
+#error Wrong _VOLUMES setting
 #endif
-
-static
-WORD Fsid;              /* File system mount ID */
-
-#if _FS_RPATH
-static
-BYTE CurrVol;           /* Current drive */
+static FATFS *FatFs[_VOLUMES];	/* Pointer to the file system objects (logical drives) */
+static WORD Fsid;				/* File system mount ID */
+
+#if _FS_RPATH && _VOLUMES >= 2
+static BYTE CurrVol;			/* Current drive */
 #endif
 
 #if _FS_LOCK
-static
-FILESEM Files[_FS_LOCK];    /* File lock semaphores */
+static FILESEM Files[_FS_LOCK];	/* Open object lock semaphores */
+#endif
+
+#if _USE_LFN == 0			/* Non LFN feature */
+#define	DEFINE_NAMEBUF		BYTE sfn[12]
+#define INIT_BUF(dobj)		(dobj).fn = sfn
+#define	FREE_BUF()
+#else
+#if _MAX_LFN < 12 || _MAX_LFN > 255
+#error Wrong _MAX_LFN setting
 #endif
-
-#if _USE_LFN == 0           /* No LFN feature */
-#define DEF_NAMEBUF         BYTE sfn[12]
-#define INIT_BUF(dobj)      (dobj).fn = sfn
-#define FREE_BUF()
-
-#elif _USE_LFN == 1         /* LFN feature with static working buffer */
-static WCHAR LfnBuf[_MAX_LFN+1];
-#define DEF_NAMEBUF         BYTE sfn[12]
-#define INIT_BUF(dobj)      { (dobj).fn = sfn; (dobj).lfn = LfnBuf; }
-#define FREE_BUF()
-
-#elif _USE_LFN == 2         /* LFN feature with dynamic working buffer on the stack */
-#define DEF_NAMEBUF         BYTE sfn[12]; WCHAR lbuf[_MAX_LFN+1]
-#define INIT_BUF(dobj)      { (dobj).fn = sfn; (dobj).lfn = lbuf; }
-#define FREE_BUF()
-
-#elif _USE_LFN == 3         /* LFN feature with dynamic working buffer on the heap */
-#define DEF_NAMEBUF         BYTE sfn[12]; WCHAR *lfn
-#define INIT_BUF(dobj)      { lfn = ff_memalloc((_MAX_LFN + 1) * 2); \
-                              if (!lfn) LEAVE_FF((dobj).fs, FR_NOT_ENOUGH_CORE); \
-                              (dobj).lfn = lfn; (dobj).fn = sfn; }
-#define FREE_BUF()          ff_memfree(lfn)
-
+#if _USE_LFN == 1			/* LFN feature with static working buffer */
+static WCHAR LfnBuf[_MAX_LFN + 1];
+#define	DEFINE_NAMEBUF		BYTE sfn[12]
+#define INIT_BUF(dobj)		{ (dobj).fn = sfn; (dobj).lfn = LfnBuf; }
+#define	FREE_BUF()
+#elif _USE_LFN == 2 		/* LFN feature with dynamic working buffer on the stack */
+#define	DEFINE_NAMEBUF		BYTE sfn[12]; WCHAR lbuf[_MAX_LFN + 1]
+#define INIT_BUF(dobj)		{ (dobj).fn = sfn; (dobj).lfn = lbuf; }
+#define	FREE_BUF()
+#elif _USE_LFN == 3 		/* LFN feature with dynamic working buffer on the heap */
+#define	DEFINE_NAMEBUF		BYTE sfn[12]; WCHAR *lfn
+#define INIT_BUF(dobj)		{ lfn = ff_memalloc((_MAX_LFN + 1) * 2); if (!lfn) LEAVE_FF((dobj).fs, FR_NOT_ENOUGH_CORE); (dobj).lfn = lfn; (dobj).fn = sfn; }
+#define	FREE_BUF()			ff_memfree(lfn)
 #else
-#error Wrong LFN configuration.
+#error Wrong _USE_LFN setting
+#endif
 #endif
 
+#ifdef _EXCVT
+static const BYTE ExCvt[] = _EXCVT;	/* Upper conversion table for extended characters */
+#endif
+
+
+
 
 
 
@@ -528,267 +460,287 @@
 /* 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;
+	BYTE *d = (BYTE*)dst;
+	const BYTE *s = (const BYTE*)src;
 
 #if _WORD_ACCESS == 1
-    while (cnt >= sizeof (int)) {
-        *(int*)d = *(int*)s;
-        d += sizeof (int); s += sizeof (int);
-        cnt -= sizeof (int);
-    }
+	while (cnt >= sizeof (int)) {
+		*(int*)d = *(int*)s;
+		d += sizeof (int); s += sizeof (int);
+		cnt -= sizeof (int);
+	}
 #endif
-    while (cnt--)
-        *d++ = *s++;
+	while (cnt--)
+		*d++ = *s++;
 }
 
 /* Fill memory */
 static
 void mem_set (void* dst, int val, UINT cnt) {
-    BYTE *d = (BYTE*)dst;
-
-    while (cnt--)
-        *d++ = (BYTE)val;
+	BYTE *d = (BYTE*)dst;
+
+	while (cnt--)
+		*d++ = (BYTE)val;
 }
 
 /* Compare memory to memory */
 static
 int mem_cmp (const void* dst, const void* src, UINT cnt) {
-    const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
-    int r = 0;
-
-    while (cnt-- && (r = *d++ - *s++) == 0) ;
-    return r;
+	const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
+	int r = 0;
+
+	while (cnt-- && (r = *d++ - *s++) == 0) ;
+	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;
+	while (*str && *str != chr) str++;
+	return *str;
 }
 
 
 
+
 /*-----------------------------------------------------------------------*/
 /* Request/Release grant to access the volume                            */
 /*-----------------------------------------------------------------------*/
 #if _FS_REENTRANT
-
 static
 int lock_fs (
-    FATFS *fs       /* File system object */
+	FATFS* fs		/* File system object */
 )
 {
-    return ff_req_grant(fs->sobj);
+	return ff_req_grant(fs->sobj);
 }
 
 
 static
 void unlock_fs (
-    FATFS *fs,      /* File system object */
-    FRESULT res     /* Result code to be returned */
+	FATFS* fs,		/* File system object */
+	FRESULT res		/* Result code to be returned */
 )
 {
-    if (fs &&
-        res != FR_NOT_ENABLED &&
-        res != FR_INVALID_DRIVE &&
-        res != FR_INVALID_OBJECT &&
-        res != FR_TIMEOUT) {
-        ff_rel_grant(fs->sobj);
-    }
+	if (fs &&
+		res != FR_NOT_ENABLED &&
+		res != FR_INVALID_DRIVE &&
+		res != FR_INVALID_OBJECT &&
+		res != FR_TIMEOUT) {
+		ff_rel_grant(fs->sobj);
+	}
 }
 #endif
 
 
 
+
 /*-----------------------------------------------------------------------*/
 /* File lock control functions                                           */
 /*-----------------------------------------------------------------------*/
 #if _FS_LOCK
 
 static
-FRESULT chk_lock (  /* Check if the file can be accessed */
-    DIR* dj,        /* Directory object pointing the file to be checked */
-    int acc         /* Desired access (0:Read, 1:Write, 2:Delete/Rename) */
+FRESULT chk_lock (	/* Check if the file can be accessed */
+	FATFS_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 == dj->fs &&        /* Check if the file matched with an open file */
-                Files[i].clu == dj->sclust &&
-                Files[i].idx == dj->index) break;
-        } else {            /* Blank entry */
-            be++;
-        }
-    }
-    if (i == _FS_LOCK)  /* The file is not opened */
-        return (be || acc == 2) ? FR_OK : FR_TOO_MANY_OPEN_FILES;   /* Is there a blank entry for new file? */
-
-    /* The file has been opened. Reject any open against writing file and all write mode open */
-    return (acc || Files[i].ctr == 0x100) ? FR_LOCKED : FR_OK;
+	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->fs &&	 	/* Check if the object matched with an open object */
+				Files[i].clu == dp->sclust &&
+				Files[i].idx == dp->index) 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 file */
+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;
+	UINT i;
+
+	for (i = 0; i < _FS_LOCK && Files[i].fs; i++) ;
+	return (i == _FS_LOCK) ? 0 : 1;
 }
 
 
 static
-UINT inc_lock ( /* Increment file open counter and returns its index (0:int error) */
-    DIR* dj,    /* Directory object pointing the file to register or increment */
-    int acc     /* Desired access mode (0:Read, !0:Write) */
+UINT inc_lock (	/* Increment object open counter and returns its index (0:Internal error) */
+	FATFS_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 file */
-        if (Files[i].fs == dj->fs &&
-            Files[i].clu == dj->sclust &&
-            Files[i].idx == dj->index) 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 space to register (int err) */
-        Files[i].fs = dj->fs;
-        Files[i].clu = dj->sclust;
-        Files[i].idx = dj->index;
-        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;
+	UINT i;
+
+
+	for (i = 0; i < _FS_LOCK; i++) {	/* Find the object */
+		if (Files[i].fs == dp->fs &&
+			Files[i].clu == dp->sclust &&
+			Files[i].idx == dp->index) 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->fs;
+		Files[i].clu = dp->sclust;
+		Files[i].idx = dp->index;
+		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 file open counter */
-    UINT i          /* Semaphore index */
+FRESULT dec_lock (	/* Decrement object open counter */
+	UINT i			/* Semaphore index (1..) */
 )
 {
-    WORD n;
-    FRESULT res;
-
-
-    if (--i < _FS_LOCK) {
-        n = Files[i].ctr;
-        if (n == 0x100) n = 0;
-        if (n) n--;
-        Files[i].ctr = n;
-        if (!n) Files[i].fs = 0;
-        res = FR_OK;
-    } else {
-        res = FR_INT_ERR;
-    }
-    return res;
+	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) n--;					/* Decrement read mode open count */
+		Files[i].ctr = n;
+		if (!n) 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
+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;
-    }
+	UINT i;
+
+	for (i = 0; i < _FS_LOCK; i++) {
+		if (Files[i].fs == fs) Files[i].fs = 0;
+	}
 }
 #endif
 
 
 
+
 /*-----------------------------------------------------------------------*/
-/* Change window offset                                                  */
+/* Move/Flush disk access window in the file system object               */
 /*-----------------------------------------------------------------------*/
+#if !_FS_READONLY
+static
+FRESULT sync_window (
+	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 (
-    FATFS *fs,      /* File system object */
-    DWORD sector    /* Sector number to make appearance in the fs->win[] */
-)                   /* Move to zero only writes back dirty window */
+	FATFS* fs,		/* File system object */
+	DWORD sector	/* Sector number to make appearance in the fs->win[] */
+)
 {
-    DWORD wsect;
-
-
-    wsect = fs->winsect;
-    if (wsect != sector) {  /* Changed current window */
+	FRESULT res = FR_OK;
+
+
+	if (sector != fs->winsect) {	/* Window offset changed? */
 #if !_FS_READONLY
-        if (fs->wflag) {    /* Write back dirty window if needed */
-            if (disk_write(fs->drv, fs->win, wsect, 1) != RES_OK)
-                return FR_DISK_ERR;
-            fs->wflag = 0;
-            if (wsect < (fs->fatbase + fs->fsize)) {    /* In FAT area */
-                BYTE nf;
-                for (nf = fs->n_fats; nf > 1; nf--) {   /* Reflect the change to all FAT copies */
-                    wsect += fs->fsize;
-                    disk_write(fs->drv, fs->win, wsect, 1);
-                }
-            }
-        }
+		res = sync_window(fs);		/* Write-back changes */
 #endif
-        if (sector) {
-            if (disk_read(fs->drv, fs->win, sector, 1) != RES_OK)
-                return FR_DISK_ERR;
-            fs->winsect = sector;
-        }
-    }
-
-    return FR_OK;
+		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;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Clean-up cached data                                                  */
+/* Synchronize file system and strage device                             */
 /*-----------------------------------------------------------------------*/
 #if !_FS_READONLY
 static
-FRESULT sync (  /* FR_OK: successful, FR_DISK_ERR: failed */
-    FATFS *fs   /* File system object */
+FRESULT sync_fs (	/* FR_OK: successful, FR_DISK_ERR: failed */
+	FATFS* fs		/* File system object */
 )
 {
-    FRESULT res;
-
-
-    res = move_window(fs, 0);
-    if (res == FR_OK) {
-        /* Update FSInfo sector if needed */
-        if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {
-            fs->winsect = 0;
-            /* Create FSInfo structure */
-            mem_set(fs->win, 0, 512);
-            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_clust);
-            ST_DWORD(fs->win+FSI_Nxt_Free, fs->last_clust);
-            /* Write it into the FSInfo sector */
-            disk_write(fs->drv, fs->win, fs->fsi_sector, 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;
+	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_clust);
+			ST_DWORD(fs->win + FSI_Nxt_Free, fs->last_clust);
+			/* 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
 
@@ -798,16 +750,16 @@
 /*-----------------------------------------------------------------------*/
 /* Get sector# from cluster#                                             */
 /*-----------------------------------------------------------------------*/
-
-
-DWORD clust2sect (  /* !=0: Sector number, 0: Failed - invalid cluster# */
-    FATFS *fs,      /* File system object */
-    DWORD clst      /* Cluster# to be converted */
+/* Hidden API for hacks and disk tools */
+
+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;
+	clst -= 2;
+	if (clst >= fs->n_fatent - 2) return 0;		/* Invalid cluster# */
+	return clst * fs->csize + fs->database;
 }
 
 
@@ -816,41 +768,52 @@
 /*-----------------------------------------------------------------------*/
 /* FAT access - Read value of a FAT entry                                */
 /*-----------------------------------------------------------------------*/
-
-
-DWORD get_fat ( /* 0xFFFFFFFF:Disk error, 1:Internal error, Else:Cluster status */
-    FATFS *fs,  /* File system object */
-    DWORD clst  /* Cluster# to get the link information */
+/* Hidden API for hacks and disk tools */
+
+DWORD get_fat (	/* 0xFFFFFFFF:Disk error, 1:Internal error, 2..0x0FFFFFFF:Cluster status */
+	FATFS* fs,	/* File system object */
+	DWORD clst	/* FAT index number (cluster number) to get the value */
 )
 {
-    UINT wc, bc;
-    BYTE *p;
-
-
-    if (clst < 2 || clst >= fs->n_fatent)   /* Check range */
-        return 1;
-
-    switch (fs->fs_type) {
-    case FS_FAT12 :
-        bc = (UINT)clst; bc += bc / 2;
-        if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break;
-        wc = fs->win[bc % SS(fs)]; bc++;
-        if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break;
-        wc |= fs->win[bc % SS(fs)] << 8;
-        return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
-
-    case FS_FAT16 :
-        if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)))) break;
-        p = &fs->win[clst * 2 % SS(fs)];
-        return LD_WORD(p);
-
-    case FS_FAT32 :
-        if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)))) break;
-        p = &fs->win[clst * 4 % SS(fs)];
-        return LD_DWORD(p) & 0x0FFFFFFF;
-    }
-
-    return 0xFFFFFFFF;  /* An error occurred at the disk I/O layer */
+	UINT wc, bc;
+	BYTE *p;
+	DWORD val;
+
+
+	if (clst < 2 || clst >= fs->n_fatent) {	/* Check 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;
+			p = &fs->win[clst * 2 % SS(fs)];
+			val = LD_WORD(p);
+			break;
+
+		case FS_FAT32 :
+			if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) != FR_OK) break;
+			p = &fs->win[clst * 4 % SS(fs)];
+			val = LD_DWORD(p) & 0x0FFFFFFF;
+			break;
+
+		default:
+			val = 1;	/* Internal error */
+		}
+	}
+
+	return val;
 }
 
 
@@ -859,60 +822,62 @@
 /*-----------------------------------------------------------------------*/
 /* FAT access - Change value of a FAT entry                              */
 /*-----------------------------------------------------------------------*/
+/* Hidden API for hacks and disk tools */
+
 #if !_FS_READONLY
-
 FRESULT put_fat (
-    FATFS *fs,  /* File system object */
-    DWORD clst, /* Cluster# to be changed in range of 2 to fs->n_fatent - 1 */
-    DWORD val   /* New value to mark the cluster */
+	FATFS* fs,	/* 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;
-
-
-    if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
-        res = FR_INT_ERR;
-
-    } else {
-        switch (fs->fs_type) {
-        case FS_FAT12 :
-            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;
-            bc++;
-            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));
-            break;
-
-        case FS_FAT16 :
-            res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)));
-            if (res != FR_OK) break;
-            p = &fs->win[clst * 2 % SS(fs)];
-            ST_WORD(p, (WORD)val);
-            break;
-
-        case FS_FAT32 :
-            res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)));
-            if (res != FR_OK) break;
-            p = &fs->win[clst * 4 % SS(fs)];
-            val |= LD_DWORD(p) & 0xF0000000;
-            ST_DWORD(p, val);
-            break;
-
-        default :
-            res = FR_INT_ERR;
-        }
-        fs->wflag = 1;
-    }
-
-    return res;
+	UINT bc;
+	BYTE *p;
+	FRESULT res;
+
+
+	if (clst < 2 || clst >= fs->n_fatent) {	/* Check range */
+		res = FR_INT_ERR;
+
+	} else {
+		switch (fs->fs_type) {
+		case FS_FAT12 :
+			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 :
+			res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)));
+			if (res != FR_OK) break;
+			p = &fs->win[clst * 2 % SS(fs)];
+			ST_WORD(p, (WORD)val);
+			fs->wflag = 1;
+			break;
+
+		case FS_FAT32 :
+			res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)));
+			if (res != FR_OK) break;
+			p = &fs->win[clst * 4 % SS(fs)];
+			val |= LD_DWORD(p) & 0xF0000000;
+			ST_DWORD(p, val);
+			fs->wflag = 1;
+			break;
+
+		default :
+			res = FR_INT_ERR;
+		}
+	}
+
+	return res;
 }
 #endif /* !_FS_READONLY */
 
@@ -925,47 +890,47 @@
 #if !_FS_READONLY
 static
 FRESULT remove_chain (
-    FATFS *fs,          /* File system object */
-    DWORD clst          /* Cluster# to remove a chain from */
+	FATFS* fs,			/* File system object */
+	DWORD clst			/* Cluster# to remove a chain from */
 )
 {
-    FRESULT res;
-    DWORD nxt;
-#if _USE_ERASE
-    DWORD scl = clst, ecl = clst, rt[2];
+	FRESULT res;
+	DWORD nxt;
+#if _USE_TRIM
+	DWORD scl = clst, ecl = clst, rt[2];
 #endif
 
-    if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
-        res = FR_INT_ERR;
-
-    } else {
-        res = FR_OK;
-        while (clst < fs->n_fatent) {           /* Not a last link? */
-            nxt = get_fat(fs, clst);            /* Get cluster status */
-            if (nxt == 0) break;                /* Empty cluster? */
-            if (nxt == 1) { res = FR_INT_ERR; break; }  /* Internal error? */
-            if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }    /* Disk error? */
-            res = put_fat(fs, clst, 0);         /* Mark the cluster "empty" */
-            if (res != FR_OK) break;
-            if (fs->free_clust != 0xFFFFFFFF) { /* Update FSInfo */
-                fs->free_clust++;
-                fs->fsi_flag = 1;
-            }
-#if _USE_ERASE
-            if (ecl + 1 == nxt) {   /* Is next cluster contiguous? */
-                ecl = nxt;
-            } else {                /* End of contiguous clusters */
-                rt[0] = clust2sect(fs, scl);                    /* Start sector */
-                rt[1] = clust2sect(fs, ecl) + fs->csize - 1;    /* End sector */
-                disk_ioctl(fs->drv, CTRL_ERASE_SECTOR, rt);     /* Erase the block */
-                scl = ecl = nxt;
-            }
+	if (clst < 2 || clst >= fs->n_fatent) {	/* Check range */
+		res = FR_INT_ERR;
+
+	} else {
+		res = FR_OK;
+		while (clst < fs->n_fatent) {			/* Not a last link? */
+			nxt = get_fat(fs, clst);			/* Get cluster status */
+			if (nxt == 0) break;				/* Empty cluster? */
+			if (nxt == 1) { res = FR_INT_ERR; break; }	/* Internal error? */
+			if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }	/* Disk error? */
+			res = put_fat(fs, clst, 0);			/* Mark the cluster "empty" */
+			if (res != FR_OK) break;
+			if (fs->free_clust != 0xFFFFFFFF) {	/* Update FSINFO */
+				fs->free_clust++;
+				fs->fsi_flag |= 1;
+			}
+#if _USE_TRIM
+			if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+				ecl = nxt;
+			} else {				/* End of contiguous clusters */ 
+				rt[0] = clust2sect(fs, scl);					/* Start sector */
+				rt[1] = clust2sect(fs, ecl) + fs->csize - 1;	/* End sector */
+				disk_ioctl(fs->drv, CTRL_TRIM, rt);				/* Erase the block */
+				scl = ecl = nxt;
+			}
 #endif
-            clst = nxt; /* Next cluster */
-        }
-    }
-
-    return res;
+			clst = nxt;	/* Next cluster */
+		}
+	}
+
+	return res;
 }
 #endif
 
@@ -977,85 +942,88 @@
 /*-----------------------------------------------------------------------*/
 #if !_FS_READONLY
 static
-DWORD create_chain (    /* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */
-    FATFS *fs,          /* File system object */
-    DWORD clst          /* Cluster# to stretch. 0 means create a new chain. */
+DWORD create_chain (	/* 0:No free cluster, 1:Internal error, 0xFFFFFFFF:Disk error, >=2:New cluster# */
+	FATFS* fs,			/* File system object */
+	DWORD clst			/* Cluster# to stretch. 0 means create a new chain. */
 )
 {
-    DWORD cs, ncl, scl;
-    FRESULT res;
-
-
-    if (clst == 0) {        /* Create a new chain */
-        scl = fs->last_clust;           /* Get suggested start point */
-        if (!scl || scl >= fs->n_fatent) scl = 1;
-    }
-    else {                  /* Stretch the current chain */
-        cs = get_fat(fs, clst);         /* Check the cluster status */
-        if (cs < 2) return 1;           /* It is an invalid cluster */
-        if (cs < fs->n_fatent) return cs;   /* It is already followed by next cluster */
-        scl = clst;
-    }
-
-    ncl = scl;              /* Start cluster */
-    for (;;) {
-        ncl++;                          /* Next cluster */
-        if (ncl >= fs->n_fatent) {      /* Wrap around */
-            ncl = 2;
-            if (ncl > scl) return 0;    /* No free cluster */
-        }
-        cs = get_fat(fs, ncl);          /* Get the cluster status */
-        if (cs == 0) break;             /* Found a free cluster */
-        if (cs == 0xFFFFFFFF || cs == 1)/* An error occurred */
-            return cs;
-        if (ncl == scl) return 0;       /* No free cluster */
-    }
-
-    res = put_fat(fs, ncl, 0x0FFFFFFF); /* Mark the new cluster "last link" */
-    if (res == FR_OK && clst != 0) {
-        res = put_fat(fs, clst, ncl);   /* Link it to the previous one if needed */
-    }
-    if (res == FR_OK) {
-        fs->last_clust = ncl;           /* Update FSINFO */
-        if (fs->free_clust != 0xFFFFFFFF) {
-            fs->free_clust--;
-            fs->fsi_flag = 1;
-        }
-    } else {
-        ncl = (res == FR_DISK_ERR) ? 0xFFFFFFFF : 1;
-    }
-
-    return ncl;     /* Return new cluster number or error code */
+	DWORD cs, ncl, scl;
+	FRESULT res;
+
+
+	if (clst == 0) {		/* Create a new chain */
+		scl = fs->last_clust;			/* Get suggested start point */
+		if (!scl || scl >= fs->n_fatent) scl = 1;
+	}
+	else {					/* Stretch the current chain */
+		cs = get_fat(fs, 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;
+	}
+
+	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(fs, ncl);			/* Get the cluster status */
+		if (cs == 0) break;				/* Found a free cluster */
+		if (cs == 0xFFFFFFFF || cs == 1)/* An error occurred */
+			return cs;
+		if (ncl == scl) return 0;		/* No free cluster */
+	}
+
+	res = put_fat(fs, ncl, 0x0FFFFFFF);	/* Mark the new cluster "last link" */
+	if (res == FR_OK && clst != 0) {
+		res = put_fat(fs, clst, ncl);	/* Link it to the previous one if needed */
+	}
+	if (res == FR_OK) {
+		fs->last_clust = ncl;			/* Update FSINFO */
+		if (fs->free_clust != 0xFFFFFFFF) {
+			fs->free_clust--;
+			fs->fsi_flag |= 1;
+		}
+	} else {
+		ncl = (res == FR_DISK_ERR) ? 0xFFFFFFFF : 1;
+	}
+
+	return ncl;		/* Return new cluster number or error code */
 }
 #endif /* !_FS_READONLY */
 
 
 
+
 /*-----------------------------------------------------------------------*/
 /* FAT handling - Convert offset into cluster with link map table        */
 /*-----------------------------------------------------------------------*/
 
 #if _USE_FASTSEEK
 static
-DWORD clmt_clust (  /* <2:Error, >=2:Cluster number */
-    FIL* fp,        /* Pointer to the file object */
-    DWORD ofs       /* File offset to be converted to cluster# */
+DWORD clmt_clust (	/* <2:Error, >=2:Cluster number */
+	FIL* fp,		/* Pointer to the file object */
+	DWORD ofs		/* File offset to be converted to cluster# */
 )
 {
-    DWORD cl, ncl, *tbl;
-
-
-    tbl = fp->cltbl + 1;    /* Top of CLMT */
-    cl = ofs / SS(fp->fs) / fp->fs->csize;  /* Cluster order from top of the file */
-    for (;;) {
-        ncl = *tbl++;           /* Number of cluters in the fragment */
-        if (!ncl) 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 */
+	DWORD cl, ncl, *tbl;
+
+
+	tbl = fp->cltbl + 1;	/* Top of CLMT */
+	cl = ofs / SS(fp->fs) / fp->fs->csize;	/* Cluster order from top of the file */
+	for (;;) {
+		ncl = *tbl++;			/* Number of cluters in the fragment */
+		if (!ncl) 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 */
+#endif	/* _USE_FASTSEEK */
+
 
 
 
@@ -1065,43 +1033,43 @@
 
 static
 FRESULT dir_sdi (
-    FATFS_DIR *dj,        /* Pointer to directory object */
-    WORD idx        /* Index of directory table */
+	FATFS_DIR* dp,		/* Pointer to directory object */
+	UINT idx		/* Index of directory table */
 )
 {
-    DWORD clst;
-    WORD ic;
-
-
-    dj->index = idx;
-    clst = dj->sclust;
-    if (clst == 1 || clst >= dj->fs->n_fatent)  /* Check start cluster range */
-        return FR_INT_ERR;
-    if (!clst && dj->fs->fs_type == FS_FAT32)   /* Replace cluster# 0 with root cluster# if in FAT32 */
-        clst = dj->fs->dirbase;
-
-    if (clst == 0) {    /* Static table (root-dir in FAT12/16) */
-        dj->clust = clst;
-        if (idx >= dj->fs->n_rootdir)       /* Index is out of range */
-            return FR_INT_ERR;
-        dj->sect = dj->fs->dirbase + idx / (SS(dj->fs) / SZ_DIR);   /* Sector# */
-    }
-    else {              /* Dynamic table (sub-dirs or root-dir in FAT32) */
-        ic = SS(dj->fs) / SZ_DIR * dj->fs->csize;   /* Entries per cluster */
-        while (idx >= ic) { /* Follow cluster chain */
-            clst = get_fat(dj->fs, clst);               /* Get next cluster */
-            if (clst == 0xFFFFFFFF) return FR_DISK_ERR; /* Disk error */
-            if (clst < 2 || clst >= dj->fs->n_fatent)   /* Reached to end of table or int error */
-                return FR_INT_ERR;
-            idx -= ic;
-        }
-        dj->clust = clst;
-        dj->sect = clust2sect(dj->fs, clst) + idx / (SS(dj->fs) / SZ_DIR);  /* Sector# */
-    }
-
-    dj->dir = dj->fs->win + (idx % (SS(dj->fs) / SZ_DIR)) * SZ_DIR; /* Ptr to the entry in the sector */
-
-    return FR_OK;   /* Seek succeeded */
+	DWORD clst, sect;
+	UINT ic;
+
+
+	dp->index = (WORD)idx;	/* Current index */
+	clst = dp->sclust;		/* Table start cluster (0:root) */
+	if (clst == 1 || clst >= dp->fs->n_fatent)	/* Check start cluster range */
+		return FR_INT_ERR;
+	if (!clst && dp->fs->fs_type == FS_FAT32)	/* Replace cluster# 0 with root cluster# if in FAT32 */
+		clst = dp->fs->dirbase;
+
+	if (clst == 0) {	/* Static table (root-directory in FAT12/16) */
+		if (idx >= dp->fs->n_rootdir)	/* Is index out of range? */
+			return FR_INT_ERR;
+		sect = dp->fs->dirbase;
+	}
+	else {				/* Dynamic table (root-directory in FAT32 or sub-directory) */
+		ic = SS(dp->fs) / SZ_DIRE * dp->fs->csize;	/* Entries per cluster */
+		while (idx >= ic) {	/* Follow cluster chain */
+			clst = get_fat(dp->fs, clst);				/* Get next cluster */
+			if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */
+			if (clst < 2 || clst >= dp->fs->n_fatent)	/* Reached to end of table or internal error */
+				return FR_INT_ERR;
+			idx -= ic;
+		}
+		sect = clust2sect(dp->fs, clst);
+	}
+	dp->clust = clst;	/* Current cluster# */
+	if (!sect) return FR_INT_ERR;
+	dp->sect = sect + idx / (SS(dp->fs) / SZ_DIRE);					/* Sector# of the directory entry */
+	dp->FATFS_DIR = dp->fs->win + (idx % (SS(dp->fs) / SZ_DIRE)) * SZ_DIRE;	/* Ptr to the entry in the sector */
+
+	return FR_OK;
 }
 
 
@@ -1112,201 +1080,241 @@
 /*-----------------------------------------------------------------------*/
 
 static
-FRESULT dir_next (  /* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not stretch */
-    FATFS_DIR *dj,        /* Pointer to directory object */
-    int stretch     /* 0: Do not stretch table, 1: Stretch table if needed */
+FRESULT dir_next (	/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:Could not stretch */
+	FATFS_DIR* dp,		/* Pointer to the directory object */
+	int stretch		/* 0: Do not stretch table, 1: Stretch table if needed */
 )
 {
-    DWORD clst;
-    WORD i;
-
-
-    stretch = stretch;      /* To suppress warning on read-only cfg. */
-    i = dj->index + 1;
-    if (!i || !dj->sect)    /* Report EOT when index has reached 65535 */
-        return FR_NO_FILE;
-
-    if (!(i % (SS(dj->fs) / SZ_DIR))) { /* Sector changed? */
-        dj->sect++;                 /* Next sector */
-
-        if (dj->clust == 0) {   /* Static table */
-            if (i >= dj->fs->n_rootdir) /* Report EOT when end of table */
-                return FR_NO_FILE;
-        }
-        else {                  /* Dynamic table */
-            if (((i / (SS(dj->fs) / SZ_DIR)) & (dj->fs->csize - 1)) == 0) { /* Cluster changed? */
-                clst = get_fat(dj->fs, dj->clust);              /* Get next cluster */
-                if (clst <= 1) return FR_INT_ERR;
-                if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
-                if (clst >= dj->fs->n_fatent) {                 /* When it reached end of dynamic table */
+	DWORD clst;
+	UINT i;
+#if !_FS_READONLY
+	UINT c;
+#endif
+
+
+	i = dp->index + 1;
+	if (!(i & 0xFFFF) || !dp->sect)	/* Report EOT when index has reached 65535 */
+		return FR_NO_FILE;
+
+	if (!(i % (SS(dp->fs) / SZ_DIRE))) {	/* Sector changed? */
+		dp->sect++;					/* Next sector */
+
+		if (!dp->clust) {		/* Static table */
+			if (i >= dp->fs->n_rootdir)	/* Report EOT if it reached end of static table */
+				return FR_NO_FILE;
+		}
+		else {					/* Dynamic table */
+			if (((i / (SS(dp->fs) / SZ_DIRE)) & (dp->fs->csize - 1)) == 0) {	/* Cluster changed? */
+				clst = get_fat(dp->fs, dp->clust);				/* Get next cluster */
+				if (clst <= 1) return FR_INT_ERR;
+				if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+				if (clst >= dp->fs->n_fatent) {					/* If it reached end of dynamic table, */
 #if !_FS_READONLY
-                    BYTE c;
-                    if (!stretch) return FR_NO_FILE;            /* When do not stretch, report EOT */
-                    clst = create_chain(dj->fs, dj->clust);     /* Stretch cluster chain */
-                    if (clst == 0) return FR_DENIED;            /* No free cluster */
-                    if (clst == 1) return FR_INT_ERR;
-                    if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
-                    /* Clean-up stretched table */
-                    if (move_window(dj->fs, 0)) return FR_DISK_ERR; /* Flush active window */
-                    mem_set(dj->fs->win, 0, SS(dj->fs));            /* Clear window buffer */
-                    dj->fs->winsect = clust2sect(dj->fs, clst); /* Cluster start sector */
-                    for (c = 0; c < dj->fs->csize; c++) {       /* Fill the new cluster with 0 */
-                        dj->fs->wflag = 1;
-                        if (move_window(dj->fs, 0)) return FR_DISK_ERR;
-                        dj->fs->winsect++;
-                    }
-                    dj->fs->winsect -= c;                       /* Rewind window address */
+					if (!stretch) return FR_NO_FILE;			/* If do not stretch, report EOT */
+					clst = create_chain(dp->fs, dp->clust);		/* Stretch cluster chain */
+					if (clst == 0) return FR_DENIED;			/* No free cluster */
+					if (clst == 1) return FR_INT_ERR;
+					if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
+					/* Clean-up stretched table */
+					if (sync_window(dp->fs)) return FR_DISK_ERR;/* Flush disk access window */
+					mem_set(dp->fs->win, 0, SS(dp->fs));		/* Clear window buffer */
+					dp->fs->winsect = clust2sect(dp->fs, clst);	/* Cluster start sector */
+					for (c = 0; c < dp->fs->csize; c++) {		/* Fill the new cluster with 0 */
+						dp->fs->wflag = 1;
+						if (sync_window(dp->fs)) return FR_DISK_ERR;
+						dp->fs->winsect++;
+					}
+					dp->fs->winsect -= c;						/* Rewind window offset */
 #else
-                    return FR_NO_FILE;          /* Report EOT */
+					if (!stretch) return FR_NO_FILE;			/* If do not stretch, report EOT (this is to suppress warning) */
+					return FR_NO_FILE;							/* Report EOT */
 #endif
-                }
-                dj->clust = clst;               /* Initialize data for new cluster */
-                dj->sect = clust2sect(dj->fs, clst);
-            }
-        }
-    }
-
-    dj->index = i;
-    dj->dir = dj->fs->win + (i % (SS(dj->fs) / SZ_DIR)) * SZ_DIR;
-
-    return FR_OK;
+				}
+				dp->clust = clst;				/* Initialize data for new cluster */
+				dp->sect = clust2sect(dp->fs, clst);
+			}
+		}
+	}
+
+	dp->index = (WORD)i;	/* Current index */
+	dp->FATFS_DIR = dp->fs->win + (i % (SS(dp->fs) / SZ_DIRE)) * SZ_DIRE;	/* Current entry in the window */
+
+	return FR_OK;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
+/* Directory handling - Reserve directory entry                          */
+/*-----------------------------------------------------------------------*/
+
+#if !_FS_READONLY
+static
+FRESULT dir_alloc (
+	FATFS_DIR* dp,	/* Pointer to the directory object */
+	UINT nent	/* Number of contiguous entries to allocate (1-21) */
+)
+{
+	FRESULT res;
+	UINT n;
+
+
+	res = dir_sdi(dp, 0);
+	if (res == FR_OK) {
+		n = 0;
+		do {
+			res = move_window(dp->fs, dp->sect);
+			if (res != FR_OK) break;
+			if (dp->FATFS_DIR[0] == DDEM || dp->FATFS_DIR[0] == 0) {	/* Is it a free entry? */
+				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);		/* Next entry with table stretch enabled */
+		} while (res == FR_OK);
+	}
+	if (res == FR_NO_FILE) res = FR_DENIED;	/* No directory entry to allocate */
+	return res;
+}
+#endif
+
+
+
+
+/*-----------------------------------------------------------------------*/
 /* Directory handling - Load/Store start cluster number                  */
 /*-----------------------------------------------------------------------*/
 
 static
 DWORD ld_clust (
-    FATFS *fs,  /* Pointer to the fs object */
-    BYTE *dir   /* Pointer to the directory entry */
+	FATFS* fs,	/* Pointer to the fs object */
+	BYTE* FATFS_DIR	/* Pointer to the directory 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;
+	DWORD cl;
+
+	cl = LD_WORD(FATFS_DIR + DIR_FstClusLO);
+	if (fs->fs_type == FS_FAT32)
+		cl |= (DWORD)LD_WORD(FATFS_DIR + DIR_FstClusHI) << 16;
+
+	return cl;
 }
 
 
 #if !_FS_READONLY
 static
 void st_clust (
-    BYTE *dir,  /* Pointer to the directory entry */
-    DWORD cl    /* Value to be set */
+	BYTE* FATFS_DIR,	/* Pointer to the directory entry */
+	DWORD cl	/* Value to be set */
 )
 {
-    ST_WORD(dir+DIR_FstClusLO, cl);
-    ST_WORD(dir+DIR_FstClusHI, cl >> 16);
+	ST_WORD(FATFS_DIR + DIR_FstClusLO, cl);
+	ST_WORD(FATFS_DIR + DIR_FstClusHI, cl >> 16);
 }
 #endif
 
 
 
+
 /*-----------------------------------------------------------------------*/
 /* LFN handling - Test/Pick/Fit an LFN segment from/to directory entry   */
 /*-----------------------------------------------------------------------*/
 #if _USE_LFN
 static
-const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};  /* Offset of LFN chars in the directory entry */
+const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};	/* Offset of LFN characters in the directory entry */
 
 
 static
-int cmp_lfn (           /* 1:Matched, 0:Not matched */
-    WCHAR *lfnbuf,      /* Pointer to the LFN to be compared */
-    BYTE *dir           /* Pointer to the directory entry containing a part of LFN */
+int cmp_lfn (			/* 1:Matched, 0:Not matched */
+	WCHAR* lfnbuf,		/* Pointer to the LFN to be compared */
+	BYTE* FATFS_DIR			/* Pointer to the directory entry containing a part of LFN */
 )
 {
-    UINT i, s;
-    WCHAR wc, uc;
-
-
-    i = ((dir[LDIR_Ord] & ~LLE) - 1) * 13;  /* Get offset in the LFN buffer */
-    s = 0; wc = 1;
-    do {
-        uc = LD_WORD(dir+LfnOfs[s]);    /* Pick an LFN character from the entry */
-        if (wc) {   /* Last char has not been processed */
-            wc = ff_wtoupper(uc);       /* Convert it to upper case */
-            if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++]))    /* Compare it */
-                return 0;               /* Not matched */
-        } else {
-            if (uc != 0xFFFF) return 0; /* Check filler */
-        }
-    } while (++s < 13);             /* Repeat until all chars in the entry are checked */
-
-    if ((dir[LDIR_Ord] & LLE) && wc && lfnbuf[i])   /* Last segment matched but different length */
-        return 0;
-
-    return 1;                       /* The part of LFN matched */
+	UINT i, s;
+	WCHAR wc, uc;
+
+
+	i = ((FATFS_DIR[LDIR_Ord] & ~LLEF) - 1) * 13;	/* Get offset in the LFN buffer */
+	s = 0; wc = 1;
+	do {
+		uc = LD_WORD(FATFS_DIR + LfnOfs[s]);	/* Pick an LFN character from the entry */
+		if (wc) {	/* Last character has not been processed */
+			wc = ff_wtoupper(uc);		/* Convert it to upper case */
+			if (i >= _MAX_LFN || wc != ff_wtoupper(lfnbuf[i++]))	/* Compare it */
+				return 0;				/* Not matched */
+		} else {
+			if (uc != 0xFFFF) return 0;	/* Check filler */
+		}
+	} while (++s < 13);				/* Repeat until all characters in the entry are checked */
+
+	if ((FATFS_DIR[LDIR_Ord] & LLEF) && wc && lfnbuf[i])	/* Last segment matched but different length */
+		return 0;
+
+	return 1;						/* The part of LFN matched */
 }
 
 
 
 static
-int pick_lfn (          /* 1:Succeeded, 0:Buffer overflow */
-    WCHAR *lfnbuf,      /* Pointer to the Unicode-LFN buffer */
-    BYTE *dir           /* Pointer to the directory entry */
+int pick_lfn (			/* 1:Succeeded, 0:Buffer overflow */
+	WCHAR* lfnbuf,		/* Pointer to the Unicode-LFN buffer */
+	BYTE* FATFS_DIR			/* Pointer to the directory entry */
 )
 {
-    UINT i, s;
-    WCHAR wc, uc;
-
-
-    i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;  /* Offset in the LFN buffer */
-
-    s = 0; wc = 1;
-    do {
-        uc = LD_WORD(dir+LfnOfs[s]);        /* Pick an LFN character from the entry */
-        if (wc) {   /* Last char has not been processed */
-            if (i >= _MAX_LFN) return 0;    /* Buffer overflow? */
-            lfnbuf[i++] = wc = uc;          /* Store it */
-        } else {
-            if (uc != 0xFFFF) return 0;     /* Check filler */
-        }
-    } while (++s < 13);                     /* Read all character in the entry */
-
-    if (dir[LDIR_Ord] & LLE) {              /* Put terminator if it is the last LFN part */
-        if (i >= _MAX_LFN) return 0;        /* Buffer overflow? */
-        lfnbuf[i] = 0;
-    }
-
-    return 1;
+	UINT i, s;
+	WCHAR wc, uc;
+
+
+	i = ((FATFS_DIR[LDIR_Ord] & 0x3F) - 1) * 13;	/* Offset in the LFN buffer */
+
+	s = 0; wc = 1;
+	do {
+		uc = LD_WORD(FATFS_DIR + LfnOfs[s]);		/* Pick an LFN character from the entry */
+		if (wc) {	/* Last character has not been processed */
+			if (i >= _MAX_LFN) return 0;	/* Buffer overflow? */
+			lfnbuf[i++] = wc = uc;			/* Store it */
+		} else {
+			if (uc != 0xFFFF) return 0;		/* Check filler */
+		}
+	} while (++s < 13);						/* Read all character in the entry */
+
+	if (FATFS_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;
 }
 
 
 #if !_FS_READONLY
 static
 void fit_lfn (
-    const WCHAR *lfnbuf,    /* Pointer to the LFN buffer */
-    BYTE *dir,              /* Pointer to the directory entry */
-    BYTE ord,               /* LFN order (1-20) */
-    BYTE sum                /* SFN sum */
+	const WCHAR* lfnbuf,	/* Pointer to the LFN buffer */
+	BYTE* FATFS_DIR,				/* Pointer to the directory entry */
+	BYTE ord,				/* LFN order (1-20) */
+	BYTE sum				/* SFN sum */
 )
 {
-    UINT i, s;
-    WCHAR wc;
-
-
-    dir[LDIR_Chksum] = sum;         /* Set check sum */
-    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 buffer */
-    s = wc = 0;
-    do {
-        if (wc != 0xFFFF) wc = lfnbuf[i++]; /* Get an effective char */
-        ST_WORD(dir+LfnOfs[s], wc); /* Put it */
-        if (!wc) wc = 0xFFFF;       /* Padding chars following last char */
-    } while (++s < 13);
-    if (wc == 0xFFFF || !lfnbuf[i]) ord |= LLE; /* Bottom LFN part is the start of LFN sequence */
-    dir[LDIR_Ord] = ord;            /* Set the LFN order */
+	UINT i, s;
+	WCHAR wc;
+
+
+	FATFS_DIR[LDIR_Chksum] = sum;			/* Set check sum */
+	FATFS_DIR[LDIR_Attr] = AM_LFN;		/* Set attribute. LFN entry */
+	FATFS_DIR[LDIR_Type] = 0;
+	ST_WORD(FATFS_DIR + LDIR_FstClusLO, 0);
+
+	i = (ord - 1) * 13;				/* Get offset in the LFN buffer */
+	s = wc = 0;
+	do {
+		if (wc != 0xFFFF) wc = lfnbuf[i++];	/* Get an effective character */
+		ST_WORD(FATFS_DIR+LfnOfs[s], wc);	/* Put it */
+		if (!wc) wc = 0xFFFF;		/* Padding characters following last character */
+	} while (++s < 13);
+	if (wc == 0xFFFF || !lfnbuf[i]) ord |= LLEF;	/* Bottom LFN part is the start of LFN sequence */
+	FATFS_DIR[LDIR_Ord] = ord;			/* Set the LFN order */
 }
 
 #endif
@@ -1314,47 +1322,60 @@
 
 
 
+
 /*-----------------------------------------------------------------------*/
 /* Create numbered name                                                  */
 /*-----------------------------------------------------------------------*/
 #if _USE_LFN
+static
 void gen_numname (
-    BYTE *dst,          /* Pointer to generated SFN */
-    const BYTE *src,    /* Pointer to source SFN to be modified */
-    const WCHAR *lfn,   /* Pointer to LFN */
-    WORD seq            /* Sequence number */
+	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;
-
-
-    mem_cpy(dst, src, 11);
-
-    if (seq > 5) {  /* On many collisions, generate a hash number instead of sequential number */
-        do seq = (seq >> 1) + (seq << 15) + (WORD)*lfn++; while (*lfn);
-    }
-
-    /* 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);
+	BYTE ns[8], c;
+	UINT i, j;
+	WCHAR wc;
+	DWORD sr;
+
+
+	mem_cpy(dst, src, 11);
+
+	if (seq > 5) {	/* On 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
 
@@ -1367,14 +1388,14 @@
 #if _USE_LFN
 static
 BYTE sum_sfn (
-    const BYTE *dir     /* Ptr to directory entry */
+	const BYTE* FATFS_DIR		/* Pointer to the SFN entry */
 )
 {
-    BYTE sum = 0;
-    UINT n = 11;
-
-    do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);
-    return sum;
+	BYTE sum = 0;
+	UINT n = 11;
+
+	do sum = (sum >> 1) + (sum << 7) + *FATFS_DIR++; while (--n);
+	return sum;
 }
 #endif
 
@@ -1387,56 +1408,56 @@
 
 static
 FRESULT dir_find (
-    FATFS_DIR *dj         /* Pointer to the directory object linked to the file name */
+	FATFS_DIR* dp			/* Pointer to the directory object linked to the file name */
 )
 {
-    FRESULT res;
-    BYTE c, *dir;
+	FRESULT res;
+	BYTE c, *FATFS_DIR;
 #if _USE_LFN
-    BYTE a, ord, sum;
+	BYTE a, ord, sum;
 #endif
 
-    res = dir_sdi(dj, 0);           /* Rewind directory object */
-    if (res != FR_OK) return res;
+	res = dir_sdi(dp, 0);			/* Rewind directory object */
+	if (res != FR_OK) return res;
 
 #if _USE_LFN
-    ord = sum = 0xFF;
+	ord = sum = 0xFF; dp->lfn_idx = 0xFFFF;	/* Reset LFN sequence */
 #endif
-    do {
-        res = move_window(dj->fs, dj->sect);
-        if (res != FR_OK) break;
-        dir = dj->dir;                  /* Ptr to the directory entry of current index */
-        c = dir[DIR_Name];
-        if (c == 0) { res = FR_NO_FILE; break; }    /* Reached to end of table */
-#if _USE_LFN    /* LFN configuration */
-        a = dir[DIR_Attr] & AM_MASK;
-        if (c == DDE || ((a & AM_VOL) && a != AM_LFN)) {    /* An entry without valid data */
-            ord = 0xFF;
-        } else {
-            if (a == AM_LFN) {          /* An LFN entry is found */
-                if (dj->lfn) {
-                    if (c & LLE) {      /* Is it start of LFN sequence? */
-                        sum = dir[LDIR_Chksum];
-                        c &= ~LLE; ord = c; /* LFN start order */
-                        dj->lfn_idx = dj->index;
-                    }
-                    /* Check validity of the LFN entry and compare it with given name */
-                    ord = (c == ord && sum == dir[LDIR_Chksum] && cmp_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
-                }
-            } else {                    /* An SFN entry is found */
-                if (!ord && sum == sum_sfn(dir)) break; /* LFN matched? */
-                ord = 0xFF; dj->lfn_idx = 0xFFFF;   /* Reset LFN sequence */
-                if (!(dj->fn[NS] & NS_LOSS) && !mem_cmp(dir, dj->fn, 11)) break;    /* SFN matched? */
-            }
-        }
-#else       /* Non LFN configuration */
-        if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
-            break;
+	do {
+		res = move_window(dp->fs, dp->sect);
+		if (res != FR_OK) break;
+		FATFS_DIR = dp->FATFS_DIR;					/* Ptr to the directory entry of current index */
+		c = FATFS_DIR[DIR_Name];
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */
+#if _USE_LFN	/* LFN configuration */
+		a = FATFS_DIR[DIR_Attr] & AM_MASK;
+		if (c == DDEM || ((a & AM_VOL) && a != AM_LFN)) {	/* An entry without valid data */
+			ord = 0xFF; dp->lfn_idx = 0xFFFF;	/* Reset LFN sequence */
+		} else {
+			if (a == AM_LFN) {			/* An LFN entry is found */
+				if (dp->lfn) {
+					if (c & LLEF) {		/* Is it start of LFN sequence? */
+						sum = FATFS_DIR[LDIR_Chksum];
+						c &= ~LLEF; ord = c;	/* LFN start order */
+						dp->lfn_idx = dp->index;	/* Start index of LFN */
+					}
+					/* Check validity of the LFN entry and compare it with given name */
+					ord = (c == ord && sum == FATFS_DIR[LDIR_Chksum] && cmp_lfn(dp->lfn, FATFS_DIR)) ? ord - 1 : 0xFF;
+				}
+			} else {					/* An SFN entry is found */
+				if (!ord && sum == sum_sfn(FATFS_DIR)) break;	/* LFN matched? */
+				if (!(dp->fn[NSFLAG] & NS_LOSS) && !mem_cmp(FATFS_DIR, dp->fn, 11)) break;	/* SFN matched? */
+				ord = 0xFF; dp->lfn_idx = 0xFFFF;	/* Reset LFN sequence */
+			}
+		}
+#else		/* Non LFN configuration */
+		if (!(FATFS_DIR[DIR_Attr] & AM_VOL) && !mem_cmp(FATFS_DIR, dp->fn, 11)) /* Is it a valid entry? */
+			break;
 #endif
-        res = dir_next(dj, 0);      /* Next entry */
-    } while (res == FR_OK);
-
-    return res;
+		res = dir_next(dp, 0);		/* Next entry */
+	} while (res == FR_OK);
+
+	return res;
 }
 
 
@@ -1445,57 +1466,59 @@
 /*-----------------------------------------------------------------------*/
 /* Read an object from the directory                                     */
 /*-----------------------------------------------------------------------*/
-#if _FS_MINIMIZE <= 1
+#if _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2
 static
 FRESULT dir_read (
-    FATFS_DIR *dj         /* Pointer to the directory object that pointing the entry to be read */
+	FATFS_DIR* dp,		/* Pointer to the directory object */
+	int vol			/* Filtered by 0:file/directory or 1:volume label */
 )
 {
-    FRESULT res;
-    BYTE c, *dir;
+	FRESULT res;
+	BYTE a, c, *FATFS_DIR;
 #if _USE_LFN
-    BYTE a, ord = 0xFF, sum = 0xFF;
+	BYTE ord = 0xFF, sum = 0xFF;
 #endif
 
-    res = FR_NO_FILE;
-    while (dj->sect) {
-        res = move_window(dj->fs, dj->sect);
-        if (res != FR_OK) break;
-        dir = dj->dir;                  /* Ptr to the directory entry of current index */
-        c = dir[DIR_Name];
-        if (c == 0) { res = FR_NO_FILE; break; }    /* Reached to end of table */
-#if _USE_LFN    /* LFN configuration */
-        a = dir[DIR_Attr] & AM_MASK;
-        if (c == DDE || (!_FS_RPATH && c == '.') || ((a & AM_VOL) && a != AM_LFN)) {    /* An entry without valid data */
-            ord = 0xFF;
-        } else {
-            if (a == AM_LFN) {          /* An LFN entry is found */
-                if (c & LLE) {          /* Is it start of LFN sequence? */
-                    sum = dir[LDIR_Chksum];
-                    c &= ~LLE; ord = c;
-                    dj->lfn_idx = dj->index;
-                }
-                /* Check LFN validity and capture it */
-                ord = (c == ord && sum == dir[LDIR_Chksum] && pick_lfn(dj->lfn, dir)) ? ord - 1 : 0xFF;
-            } else {                    /* An SFN entry is found */
-                if (ord || sum != sum_sfn(dir)) /* Is there a valid LFN? */
-                    dj->lfn_idx = 0xFFFF;       /* It has no LFN. */
-                break;
-            }
-        }
-#else       /* Non LFN configuration */
-        if (c != DDE && (_FS_RPATH || c != '.') && !(dir[DIR_Attr] & AM_VOL))   /* Is it a valid entry? */
-            break;
+	res = FR_NO_FILE;
+	while (dp->sect) {
+		res = move_window(dp->fs, dp->sect);
+		if (res != FR_OK) break;
+		FATFS_DIR = dp->FATFS_DIR;					/* Ptr to the directory entry of current index */
+		c = FATFS_DIR[DIR_Name];
+		if (c == 0) { res = FR_NO_FILE; break; }	/* Reached to end of table */
+		a = FATFS_DIR[DIR_Attr] & AM_MASK;
+#if _USE_LFN	/* LFN configuration */
+		if (c == DDEM || (!_FS_RPATH && 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 LFN sequence? */
+					sum = FATFS_DIR[LDIR_Chksum];
+					c &= ~LLEF; ord = c;
+					dp->lfn_idx = dp->index;
+				}
+				/* Check LFN validity and capture it */
+				ord = (c == ord && sum == FATFS_DIR[LDIR_Chksum] && pick_lfn(dp->lfn, FATFS_DIR)) ? ord - 1 : 0xFF;
+			} else {					/* An SFN entry is found */
+				if (ord || sum != sum_sfn(FATFS_DIR))	/* Is there a valid LFN? */
+					dp->lfn_idx = 0xFFFF;		/* It has no LFN. */
+				break;
+			}
+		}
+#else		/* Non LFN configuration */
+		if (c != DDEM && (_FS_RPATH || c != '.') && a != AM_LFN && (int)((a & ~AM_ARC) == AM_VOL) == vol)	/* Is it a valid entry? */
+			break;
 #endif
-        res = dir_next(dj, 0);              /* Next entry */
-        if (res != FR_OK) break;
-    }
-
-    if (res != FR_OK) dj->sect = 0;
-
-    return res;
+		res = dir_next(dp, 0);				/* Next entry */
+		if (res != FR_OK) break;
+	}
+
+	if (res != FR_OK) dp->sect = 0;
+
+	return res;
 }
-#endif
+#endif	/* _FS_MINIMIZE <= 1 || _USE_LABEL || _FS_RPATH >= 2 */
+
 
 
 
@@ -1504,102 +1527,73 @@
 /*-----------------------------------------------------------------------*/
 #if !_FS_READONLY
 static
-FRESULT dir_register (  /* FR_OK:Successful, FR_DENIED:No free entry or too many SFN collision, FR_DISK_ERR:Disk error */
-    FATFS_DIR *dj             /* Target directory with object name to be created */
+FRESULT dir_register (	/* FR_OK:Successful, FR_DENIED:No free entry or too many SFN collision, FR_DISK_ERR:Disk error */
+	FATFS_DIR* dp				/* Target directory with object name to be created */
 )
 {
-    FRESULT res;
-    BYTE c, *dir;
-#if _USE_LFN    /* LFN configuration */
-    WORD n, ne, is;
-    BYTE sn[12], *fn, sum;
-    WCHAR *lfn;
-
-
-    fn = dj->fn; lfn = dj->lfn;
-    mem_cpy(sn, fn, 12);
-
-    if (_FS_RPATH && (sn[NS] & NS_DOT))     /* Cannot create dot entry */
-        return FR_INVALID_NAME;
-
-    if (sn[NS] & NS_LOSS) {         /* When LFN is out of 8.3 format, generate a numbered name */
-        fn[NS] = 0; dj->lfn = 0;            /* Find only SFN */
-        for (n = 1; n < 100; n++) {
-            gen_numname(fn, sn, lfn, n);    /* Generate a numbered name */
-            res = dir_find(dj);             /* 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' */
-        fn[NS] = sn[NS]; dj->lfn = lfn;
-    }
-
-    if (sn[NS] & NS_LFN) {          /* When LFN is to be created, reserve an SFN + LFN entries. */
-        for (ne = 0; lfn[ne]; ne++) ;
-        ne = (ne + 25) / 13;
-    } else {                        /* Otherwise reserve only an SFN entry. */
-        ne = 1;
-    }
-
-    /* Reserve contiguous entries */
-    res = dir_sdi(dj, 0);
-    if (res != FR_OK) return res;
-    n = is = 0;
-    do {
-        res = move_window(dj->fs, dj->sect);
-        if (res != FR_OK) break;
-        c = *dj->dir;               /* Check the entry status */
-        if (c == DDE || c == 0) {   /* Is it a blank entry? */
-            if (n == 0) is = dj->index; /* First index of the contiguous entry */
-            if (++n == ne) break;   /* A contiguous entry that required count is found */
-        } else {
-            n = 0;                  /* Not a blank entry. Restart to search */
-        }
-        res = dir_next(dj, 1);      /* Next entry with table stretch */
-    } while (res == FR_OK);
-
-    if (res == FR_OK && ne > 1) {   /* Initialize LFN entry if needed */
-        res = dir_sdi(dj, is);
-        if (res == FR_OK) {
-            sum = sum_sfn(dj->fn);  /* Sum of the SFN tied to the LFN */
-            ne--;
-            do {                    /* Store LFN entries in bottom first */
-                res = move_window(dj->fs, dj->sect);
-                if (res != FR_OK) break;
-                fit_lfn(dj->lfn, dj->dir, (BYTE)ne, sum);
-                dj->fs->wflag = 1;
-                res = dir_next(dj, 0);  /* Next entry */
-            } while (res == FR_OK && --ne);
-        }
-    }
-
-#else   /* Non LFN configuration */
-    res = dir_sdi(dj, 0);
-    if (res == FR_OK) {
-        do {    /* Find a blank entry for the SFN */
-            res = move_window(dj->fs, dj->sect);
-            if (res != FR_OK) break;
-            c = *dj->dir;
-            if (c == DDE || c == 0) break;  /* Is it a blank entry? */
-            res = dir_next(dj, 1);          /* Next entry with table stretch */
-        } while (res == FR_OK);
-    }
+	FRESULT res;
+#if _USE_LFN	/* LFN configuration */
+	UINT n, nent;
+	BYTE sn[12], *fn, sum;
+	WCHAR *lfn;
+
+
+	fn = dp->fn; lfn = dp->lfn;
+	mem_cpy(sn, fn, 12);
+
+	if (_FS_RPATH && (sn[NSFLAG] & NS_DOT))		/* Cannot create dot entry */
+		return FR_INVALID_NAME;
+
+	if (sn[NSFLAG] & NS_LOSS) {			/* When LFN is out of 8.3 format, generate a numbered name */
+		fn[NSFLAG] = 0; dp->lfn = 0;			/* Find only SFN */
+		for (n = 1; n < 100; n++) {
+			gen_numname(fn, sn, lfn, 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' */
+		fn[NSFLAG] = sn[NSFLAG]; dp->lfn = lfn;
+	}
+
+	if (sn[NSFLAG] & NS_LFN) {			/* When LFN is to be created, allocate entries for an SFN + LFNs. */
+		for (n = 0; lfn[n]; n++) ;
+		nent = (n + 25) / 13;
+	} else {						/* Otherwise allocate an entry for an SFN  */
+		nent = 1;
+	}
+	res = dir_alloc(dp, nent);		/* Allocate entries */
+
+	if (res == FR_OK && --nent) {	/* Set LFN entry if needed */
+		res = dir_sdi(dp, dp->index - nent);
+		if (res == FR_OK) {
+			sum = sum_sfn(dp->fn);	/* Sum value of the SFN tied to the LFN */
+			do {					/* Store LFN entries in bottom first */
+				res = move_window(dp->fs, dp->sect);
+				if (res != FR_OK) break;
+				fit_lfn(dp->lfn, dp->FATFS_DIR, (BYTE)nent, sum);
+				dp->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
 
-    if (res == FR_OK) {     /* Initialize the SFN entry */
-        res = move_window(dj->fs, dj->sect);
-        if (res == FR_OK) {
-            dir = dj->dir;
-            mem_set(dir, 0, SZ_DIR);    /* Clean the entry */
-            mem_cpy(dir, dj->fn, 11);   /* Put SFN */
+	if (res == FR_OK) {				/* Set SFN entry */
+		res = move_window(dp->fs, dp->sect);
+		if (res == FR_OK) {
+			mem_set(dp->FATFS_DIR, 0, SZ_DIRE);	/* Clean the entry */
+			mem_cpy(dp->FATFS_DIR, dp->fn, 11);	/* Put SFN */
 #if _USE_LFN
-            dir[DIR_NTres] = *(dj->fn+NS) & (NS_BODY | NS_EXT); /* Put NT flag */
+			dp->FATFS_DIR[DIR_NTres] = dp->fn[NSFLAG] & (NS_BODY | NS_EXT);	/* Put NT flag */
 #endif
-            dj->fs->wflag = 1;
-        }
-    }
-
-    return res;
+			dp->fs->wflag = 1;
+		}
+	}
+
+	return res;
 }
 #endif /* !_FS_READONLY */
 
@@ -1611,42 +1605,184 @@
 /*-----------------------------------------------------------------------*/
 #if !_FS_READONLY && !_FS_MINIMIZE
 static
-FRESULT dir_remove (    /* FR_OK: Successful, FR_DISK_ERR: A disk error */
-    FATFS_DIR *dj             /* Directory object pointing the entry to be removed */
+FRESULT dir_remove (	/* FR_OK: Successful, FR_DISK_ERR: A disk error */
+	FATFS_DIR* dp				/* Directory object pointing the entry to be removed */
+)
+{
+	FRESULT res;
+#if _USE_LFN	/* LFN configuration */
+	UINT i;
+
+	i = dp->index;	/* SFN index */
+	res = dir_sdi(dp, (dp->lfn_idx == 0xFFFF) ? i : dp->lfn_idx);	/* Goto the SFN or top of the LFN entries */
+	if (res == FR_OK) {
+		do {
+			res = move_window(dp->fs, dp->sect);
+			if (res != FR_OK) break;
+			mem_set(dp->FATFS_DIR, 0, SZ_DIRE);	/* Clear and mark the entry "deleted" */
+			*dp->FATFS_DIR = DDEM;
+			dp->fs->wflag = 1;
+			if (dp->index >= i) break;	/* When reached SFN, 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 = dir_sdi(dp, dp->index);
+	if (res == FR_OK) {
+		res = move_window(dp->fs, dp->sect);
+		if (res == FR_OK) {
+			mem_set(dp->FATFS_DIR, 0, SZ_DIRE);	/* Clear and mark the entry "deleted" */
+			*dp->FATFS_DIR = DDEM;
+			dp->fs->wflag = 1;
+		}
+	}
+#endif
+
+	return res;
+}
+#endif /* !_FS_READONLY */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get file information from directory entry                             */
+/*-----------------------------------------------------------------------*/
+#if _FS_MINIMIZE <= 1 || _FS_RPATH >= 2
+static
+void get_fileinfo (		/* No return code */
+	FATFS_DIR* dp,			/* Pointer to the directory object */
+	FILINFO* fno	 	/* Pointer to the file information to be filled */
 )
 {
-    FRESULT res;
-#if _USE_LFN    /* LFN configuration */
-    WORD i;
-
-    i = dj->index;  /* SFN index */
-    res = dir_sdi(dj, (WORD)((dj->lfn_idx == 0xFFFF) ? i : dj->lfn_idx));   /* Goto the SFN or top of the LFN entries */
-    if (res == FR_OK) {
-        do {
-            res = move_window(dj->fs, dj->sect);
-            if (res != FR_OK) break;
-            *dj->dir = DDE;         /* Mark the entry "deleted" */
-            dj->fs->wflag = 1;
-            if (dj->index >= i) break;  /* When reached SFN, all entries of the object has been deleted. */
-            res = dir_next(dj, 0);      /* Next entry */
-        } while (res == FR_OK);
-        if (res == FR_NO_FILE) res = FR_INT_ERR;
-    }
-
-#else           /* Non LFN configuration */
-    res = dir_sdi(dj, dj->index);
-    if (res == FR_OK) {
-        res = move_window(dj->fs, dj->sect);
-        if (res == FR_OK) {
-            *dj->dir = DDE;         /* Mark the entry "deleted" */
-            dj->fs->wflag = 1;
-        }
-    }
+	UINT i;
+	TCHAR *p, c;
+	BYTE *FATFS_DIR;
+#if _USE_LFN
+	WCHAR w, *lfn;
+#endif
+
+	p = fno->fname;
+	if (dp->sect) {		/* Get SFN */
+		FATFS_DIR = dp->FATFS_DIR;
+		i = 0;
+		while (i < 11) {		/* Copy name body and extension */
+			c = (TCHAR)FATFS_DIR[i++];
+			if (c == ' ') continue;				/* Skip padding spaces */
+			if (c == RDDEM) c = (TCHAR)DDEM;	/* Restore replaced DDEM character */
+			if (i == 9) *p++ = '.';				/* Insert a . if extension is exist */
+#if _USE_LFN
+			if (IsUpper(c) && (FATFS_DIR[DIR_NTres] & (i >= 9 ? NS_EXT : NS_BODY)))
+				c += 0x20;			/* To lower */
+#if _LFN_UNICODE
+			if (IsDBCS1(c) && i != 8 && i != 11 && IsDBCS2(FATFS_DIR[i]))
+				c = c << 8 | FATFS_DIR[i++];
+			c = ff_convert(c, 1);	/* OEM -> Unicode */
+			if (!c) c = '?';
+#endif
+#endif
+			*p++ = c;
+		}
+		fno->fattrib = FATFS_DIR[DIR_Attr];				/* Attribute */
+		fno->fsize = LD_DWORD(FATFS_DIR + DIR_FileSize);	/* Size */
+		fno->fdate = LD_WORD(FATFS_DIR + DIR_WrtDate);	/* Date */
+		fno->ftime = LD_WORD(FATFS_DIR + DIR_WrtTime);	/* Time */
+	}
+	*p = 0;		/* Terminate SFN string by a \0 */
+
+#if _USE_LFN
+	if (fno->lfname) {
+		i = 0; p = fno->lfname;
+		if (dp->sect && fno->lfsize && dp->lfn_idx != 0xFFFF) {	/* Get LFN if available */
+			lfn = dp->lfn;
+			while ((w = *lfn++) != 0) {		/* Get an LFN character */
+#if !_LFN_UNICODE
+				w = ff_convert(w, 0);		/* Unicode -> OEM */
+				if (!w) { 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 on SBCS cfg) */
+					p[i++] = (TCHAR)(w >> 8);
+#endif
+				if (i >= fno->lfsize - 1) { i = 0; break; }	/* No LFN if buffer overflow */
+				p[i++] = (TCHAR)w;
+			}
+		}
+		p[i] = 0;	/* Terminate LFN string by a \0 */
+	}
 #endif
-
-    return res;
+}
+#endif /* _FS_MINIMIZE <= 1 || _FS_RPATH >= 2 */
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Pattern matching                                                      */
+/*-----------------------------------------------------------------------*/
+#if _USE_FIND && _FS_MINIMIZE <= 1
+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 */
+)
+{
+	WCHAR chr;
+
+#if !_LFN_UNICODE
+	chr = (BYTE)*(*ptr)++;					/* Get a byte */
+	if (IsLower(chr)) chr -= 0x20;			/* To upper ASCII char */
+	if (IsDBCS1(chr) && IsDBCS2(**ptr))		/* Get DBC 2nd byte if needed */
+		chr = chr << 8 | (BYTE)*(*ptr)++;
+#ifdef _EXCVT
+	if (chr >= 0x80) chr = ExCvt[chr - 0x80];	/* To upper SBCS extended char */
+#endif
+#else
+	chr = ff_wtoupper(*(*ptr)++);			/* Get a word and to upper */
+#endif
+	return chr;
 }
-#endif /* !_FS_READONLY */
+
+
+static
+int pattern_matching (	/* Return value: 0:mismatched, 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) 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 */
 
 
 
@@ -1657,208 +1793,204 @@
 
 static
 FRESULT create_name (
-    FATFS_DIR *dj,            /* Pointer to the directory object */
-    const TCHAR **path  /* Pointer to pointer to the segment in the path string */
+	FATFS_DIR* dp,			/* Pointer to the directory object */
+	const TCHAR** path	/* Pointer to pointer to the segment in the path string */
 )
 {
-#ifdef _EXCVT
-    static const BYTE excvt[] = _EXCVT; /* Upper conversion table for extended chars */
+#if _USE_LFN	/* LFN configuration */
+	BYTE b, cf;
+	WCHAR w, *lfn;
+	UINT i, ni, si, di;
+	const TCHAR *p;
+
+	/* Create LFN in Unicode */
+	for (p = *path; *p == '/' || *p == '\\'; p++) ;	/* Strip duplicated separator */
+	lfn = dp->lfn;
+	si = di = 0;
+	for (;;) {
+		w = p[si++];					/* Get a character */
+		if (w < ' ' || w == '/' || w == '\\') break;	/* Break on end of segment */
+		if (di >= _MAX_LFN)				/* Reject too long name */
+			return FR_INVALID_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 _USE_LFN    /* LFN configuration */
-    BYTE b, cf;
-    WCHAR w, *lfn;
-    UINT i, ni, si, di;
-    const TCHAR *p;
-
-    /* Create LFN in Unicode */
-    for (p = *path; *p == '/' || *p == '\\'; p++) ; /* Strip duplicated separator */
-    lfn = dj->lfn;
-    si = di = 0;
-    for (;;) {
-        w = p[si++];                    /* Get a character */
-        if (w < ' ' || w == '/' || w == '\\') break;    /* Break on end of segment */
-        if (di >= _MAX_LFN)             /* Reject too long name */
-            return FR_INVALID_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 */
-            if (!IsDBCS2(b))
-                return FR_INVALID_NAME; /* Reject invalid sequence */
-            w = (w << 8) + b;           /* Create a DBC */
-        }
-        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)) /* Reject illegal chars for LFN */
-            return FR_INVALID_NAME;
-        lfn[di++] = w;                  /* Store the Unicode char */
-    }
-    *path = &p[si];                     /* Return pointer to the next segment */
-    cf = (w < ' ') ? NS_LAST : 0;       /* Set last segment flag if end of path */
+		if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal characters for LFN */
+			return FR_INVALID_NAME;
+		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 path */
 #if _FS_RPATH
-    if ((di == 1 && lfn[di-1] == '.') || /* Is this a dot entry? */
-        (di == 2 && lfn[di-1] == '.' && lfn[di-2] == '.')) {
-        lfn[di] = 0;
-        for (i = 0; i < 11; i++)
-            dj->fn[i] = (i < di) ? '.' : ' ';
-        dj->fn[i] = cf | NS_DOT;        /* This is a dot entry */
-        return FR_OK;
-    }
+	if ((di == 1 && lfn[di - 1] == '.') || /* Is this a dot entry? */
+		(di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {
+		lfn[di] = 0;
+		for (i = 0; i < 11; i++)
+			dp->fn[i] = (i < di) ? '.' : ' ';
+		dp->fn[i] = cf | NS_DOT;		/* This is a dot entry */
+		return FR_OK;
+	}
 #endif
-    while (di) {                        /* Strip trailing spaces and dots */
-        w = lfn[di-1];
-        if (w != ' ' && w != '.') break;
-        di--;
-    }
-    if (!di) return FR_INVALID_NAME;    /* Reject nul string */
-
-    lfn[di] = 0;                        /* LFN is created */
-
-    /* Create SFN in directory form */
-    mem_set(dj->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 char */
-        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 char */
+	while (di) {						/* Strip trailing spaces and dots */
+		w = lfn[di - 1];
+		if (w != ' ' && w != '.') break;
+		di--;
+	}
+	if (!di) return FR_INVALID_NAME;	/* Reject nul string */
+
+	lfn[di] = 0;						/* LFN is created */
+
+	/* 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 char to upper (SBCS) */
+			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 */
+			w = ff_convert(ff_wtoupper(w), 0);	/* Upper converted Unicode -> OEM code */
 #endif
-            cf |= NS_LFN;               /* Force create LFN entry */
-        }
-
-        if (_DF1S && w >= 0x100) {      /* Double byte char (always false on SBCS cfg) */
-            if (i >= ni - 1) {
-                cf |= NS_LOSS | NS_LFN; i = ni; continue;
-            }
-            dj->fn[i++] = (BYTE)(w >> 8);
-        } else {                        /* Single byte char */
-            if (!w || chk_chr("+,;=[]", w)) {   /* Replace illegal chars 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;
-                    }
-                }
-            }
-        }
-        dj->fn[i++] = (BYTE)w;
-    }
-
-    if (dj->fn[0] == DDE) dj->fn[0] = NDDE; /* If the first char collides with deleted mark, replace it with 0x05 */
-
-    if (ni == 8) b <<= 2;
-    if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03)   /* Create LFN entry when there are composite capitals */
-        cf |= NS_LFN;
-    if (!(cf & NS_LFN)) {                       /* When LFN is in 8.3 format without extended char, 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) */
-    }
-
-    dj->fn[NS] = cf;    /* SFN is created */
-
-    return FR_OK;
-
-
-#else   /* Non-LFN configuration */
-    BYTE b, c, d, *sfn;
-    UINT ni, si, i;
-    const char *p;
-
-    /* Create file name in directory form */
-    for (p = *path; *p == '/' || *p == '\\'; p++) ; /* Strip duplicated separator */
-    sfn = dj->fn;
-    mem_set(sfn, ' ', 11);
-    si = i = b = 0; ni = 8;
+			cf |= NS_LFN;				/* Force create LFN entry */
+		}
+
+		if (_DF1S && w >= 0x100) {		/* 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 deleted mark, replace it with RDDEM */
+
+	if (ni == 8) b <<= 2;
+	if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03)	/* Create LFN entry when there are composite capitals */
+		cf |= NS_LFN;
+	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	/* Non-LFN configuration */
+	BYTE b, c, d, *sfn;
+	UINT ni, si, i;
+	const char *p;
+
+	/* Create file name in directory form */
+	for (p = *path; *p == '/' || *p == '\\'; p++) ;	/* Strip duplicated separator */
+	sfn = dp->fn;
+	mem_set(sfn, ' ', 11);
+	si = i = b = 0; ni = 8;
 #if _FS_RPATH
-    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[NS] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT;   /* Set last segment flag if end of path */
-        return FR_OK;
-    }
+	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 path */
+		return FR_OK;
+	}
 #endif
-    for (;;) {
-        c = (BYTE)p[si++];
-        if (c <= ' ' || c == '/' || c == '\\') break;   /* Break on end of segment */
-        if (c == '.' || i >= ni) {
-            if (ni != 8 || c != '.') return FR_INVALID_NAME;
-            i = 8; ni = 11;
-            b <<= 2; continue;
-        }
-        if (c >= 0x80) {                /* Extended char? */
-            b |= 3;                     /* Eliminate NT flag */
+	for (;;) {
+		c = (BYTE)p[si++];
+		if (c <= ' ' || c == '/' || c == '\\') break;	/* Break on end of segment */
+		if (c == '.' || i >= ni) {
+			if (ni != 8 || c != '.') return FR_INVALID_NAME;
+			i = 8; ni = 11;
+			b <<= 2; continue;
+		}
+		if (c >= 0x80) {				/* Extended character? */
+			b |= 3;						/* Eliminate NT flag */
 #ifdef _EXCVT
-            c = excvt[c - 0x80];        /* Upper conversion (SBCS) */
+			c = ExCvt[c - 0x80];		/* To upper extended characters (SBCS cfg) */
 #else
-#if !_DF1S  /* ASCII only cfg */
-            return FR_INVALID_NAME;
+#if !_DF1S
+			return FR_INVALID_NAME;		/* Reject extended characters (ASCII cfg) */
 #endif
 #endif
-        }
-        if (IsDBCS1(c)) {               /* Check if it is a DBC 1st byte (always false on SBCS cfg) */
-            d = (BYTE)p[si++];          /* Get 2nd byte */
-            if (!IsDBCS2(d) || i >= ni - 1) /* Reject invalid DBC */
-                return FR_INVALID_NAME;
-            sfn[i++] = c;
-            sfn[i++] = d;
-        } else {                        /* Single byte code */
-            if (chk_chr("\"*+,:;<=>\?[]|\x7F", c))  /* Reject illegal chrs for SFN */
-                return FR_INVALID_NAME;
-            if (IsUpper(c)) {           /* ASCII large capital? */
-                b |= 2;
-            } else {
-                if (IsLower(c)) {       /* ASCII small capital? */
-                    b |= 1; c -= 0x20;
-                }
-            }
-            sfn[i++] = c;
-        }
-    }
-    *path = &p[si];                     /* Return pointer to the next segment */
-    c = (c <= ' ') ? NS_LAST : 0;       /* Set last segment flag if end of path */
-
-    if (!i) return FR_INVALID_NAME;     /* Reject nul string */
-    if (sfn[0] == DDE) sfn[0] = NDDE;   /* When first char collides with DDE, replace it with 0x05 */
-
-    if (ni == 8) b <<= 2;
-    if ((b & 0x03) == 0x01) c |= NS_EXT;    /* NT flag (Name extension has only small capital) */
-    if ((b & 0x0C) == 0x04) c |= NS_BODY;   /* NT flag (Name body has only small capital) */
-
-    sfn[NS] = c;        /* Store NT flag, File name is created */
-
-    return FR_OK;
+		}
+		if (IsDBCS1(c)) {				/* Check if it is a DBC 1st byte (always false on SBCS cfg) */
+			d = (BYTE)p[si++];			/* Get 2nd byte */
+			if (!IsDBCS2(d) || i >= ni - 1)	/* Reject invalid DBC */
+				return FR_INVALID_NAME;
+			sfn[i++] = c;
+			sfn[i++] = d;
+		} else {						/* SBC */
+			if (chk_chr("\"*+,:;<=>\?[]|\x7F", c))	/* Reject illegal chrs for SFN */
+				return FR_INVALID_NAME;
+			if (IsUpper(c)) {			/* ASCII large capital? */
+				b |= 2;
+			} else {
+				if (IsLower(c)) {		/* ASCII small capital? */
+					b |= 1; c -= 0x20;
+				}
+			}
+			sfn[i++] = c;
+		}
+	}
+	*path = &p[si];						/* Return pointer to the next segment */
+	c = (c <= ' ') ? NS_LAST : 0;		/* Set last segment flag if end of path */
+
+	if (!i) return FR_INVALID_NAME;		/* Reject nul string */
+	if (sfn[0] == DDEM) sfn[0] = RDDEM;	/* When first character collides with DDEM, replace it with RDDEM */
+
+	if (ni == 8) b <<= 2;
+	if ((b & 0x03) == 0x01) c |= NS_EXT;	/* NT flag (Name extension has only small capital) */
+	if ((b & 0x0C) == 0x04) c |= NS_BODY;	/* NT flag (Name body has only small capital) */
+
+	sfn[NSFLAG] = c;		/* Store NT flag, File name is created */
+
+	return FR_OK;
 #endif
 }
 
@@ -1866,364 +1998,346 @@
 
 
 /*-----------------------------------------------------------------------*/
-/* Get file information from directory entry                             */
-/*-----------------------------------------------------------------------*/
-#if _FS_MINIMIZE <= 1
-static
-void get_fileinfo (     /* No return code */
-    FATFS_DIR *dj,            /* Pointer to the directory object */
-    FILINFO *fno        /* Pointer to the file information to be filled */
-)
-{
-    UINT i;
-    BYTE nt, *dir;
-    TCHAR *p, c;
-
-
-    p = fno->fname;
-    if (dj->sect) {
-        dir = dj->dir;
-        nt = dir[DIR_NTres];        /* NT flag */
-        for (i = 0; i < 8; i++) {   /* Copy name body */
-            c = dir[i];
-            if (c == ' ') break;
-            if (c == NDDE) c = (TCHAR)DDE;
-            if (_USE_LFN && (nt & NS_BODY) && IsUpper(c)) c += 0x20;
-#if _LFN_UNICODE
-            if (IsDBCS1(c) && i < 7 && IsDBCS2(dir[i+1]))
-                c = (c << 8) | dir[++i];
-            c = ff_convert(c, 1);
-            if (!c) c = '?';
-#endif
-            *p++ = c;
-        }
-        if (dir[8] != ' ') {        /* Copy name extension */
-            *p++ = '.';
-            for (i = 8; i < 11; i++) {
-                c = dir[i];
-                if (c == ' ') break;
-                if (_USE_LFN && (nt & NS_EXT) && IsUpper(c)) c += 0x20;
-#if _LFN_UNICODE
-                if (IsDBCS1(c) && i < 10 && IsDBCS2(dir[i+1]))
-                    c = (c << 8) | dir[++i];
-                c = ff_convert(c, 1);
-                if (!c) c = '?';
-#endif
-                *p++ = c;
-            }
-        }
-        fno->fattrib = dir[DIR_Attr];               /* Attribute */
-        fno->fsize = LD_DWORD(dir+DIR_FileSize);    /* Size */
-        fno->fdate = LD_WORD(dir+DIR_WrtDate);      /* Date */
-        fno->ftime = LD_WORD(dir+DIR_WrtTime);      /* Time */
-    }
-    *p = 0;     /* Terminate SFN str by a \0 */
-
-#if _USE_LFN
-    if (fno->lfname && fno->lfsize) {
-        TCHAR *tp = fno->lfname;
-        WCHAR w, *lfn;
-
-        i = 0;
-        if (dj->sect && dj->lfn_idx != 0xFFFF) {/* Get LFN if available */
-            lfn = dj->lfn;
-            while ((w = *lfn++) != 0) {         /* Get an LFN char */
-#if !_LFN_UNICODE
-                w = ff_convert(w, 0);           /* Unicode -> OEM conversion */
-                if (!w) { i = 0; break; }       /* Could not convert, no LFN */
-                if (_DF1S && w >= 0x100)        /* Put 1st byte if it is a DBC (always false on SBCS cfg) */
-                    tp[i++] = (TCHAR)(w >> 8);
-#endif
-                if (i >= fno->lfsize - 1) { i = 0; break; } /* Buffer overflow, no LFN */
-                tp[i++] = (TCHAR)w;
-            }
-        }
-        tp[i] = 0;  /* Terminate the LFN str by a \0 */
-    }
-#endif
-}
-#endif /* _FS_MINIMIZE <= 1 */
-
-
-
-
-/*-----------------------------------------------------------------------*/
 /* Follow a file path                                                    */
 /*-----------------------------------------------------------------------*/
 
 static
-FRESULT follow_path (   /* FR_OK(0): successful, !=0: error code */
-    FATFS_DIR *dj,            /* Directory object to return last directory and found object */
-    const TCHAR *path   /* Full-path string to find a file or directory */
+FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */
+	FATFS_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 *dir, ns;
+	FRESULT res;
+	BYTE *FATFS_DIR, ns;
 
 
 #if _FS_RPATH
-    if (*path == '/' || *path == '\\') { /* There is a heading separator */
-        path++; dj->sclust = 0;     /* Strip it and start from the root dir */
-    } else {                            /* No heading separator */
-        dj->sclust = dj->fs->cdir;  /* Start from the current dir */
-    }
+	if (*path == '/' || *path == '\\') {	/* There is a heading separator */
+		path++;	dp->sclust = 0;				/* Strip it and start from the root directory */
+	} else {								/* No heading separator */
+		dp->sclust = dp->fs->cdir;			/* Start from the current directory */
+	}
 #else
-    if (*path == '/' || *path == '\\')  /* Strip heading separator if exist */
-        path++;
-    dj->sclust = 0;                     /* Start from the root dir */
+	if (*path == '/' || *path == '\\')		/* Strip heading separator if exist */
+		path++;
+	dp->sclust = 0;							/* Always start from the root directory */
 #endif
 
-    if ((UINT)*path < ' ') {            /* Nul path means the start directory itself */
-        res = dir_sdi(dj, 0);
-        dj->dir = 0;
-    } else {                            /* Follow path */
-        for (;;) {
-            res = create_name(dj, &path);   /* Get a segment */
-            if (res != FR_OK) break;
-            res = dir_find(dj);             /* Find it */
-            ns = *(dj->fn+NS);
-            if (res != FR_OK) {             /* Failed to find the object */
-                if (res != FR_NO_FILE) break;   /* Abort if any hard error occurred */
-                /* Object not found */
-                if (_FS_RPATH && (ns & NS_DOT)) {   /* If dot entry is not exit */
-                    dj->sclust = 0; dj->dir = 0;    /* It is the root dir */
-                    res = FR_OK;
-                    if (!(ns & NS_LAST)) continue;
-                } else {                            /* Could not find the object */
-                    if (!(ns & NS_LAST)) res = FR_NO_PATH;
-                }
-                break;
-            }
-            if (ns & NS_LAST) break;            /* Last segment match. Function completed. */
-            dir = dj->dir;                      /* 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;
-            }
-            dj->sclust = ld_clust(dj->fs, dir);
-        }
-    }
-
-    return res;
+	if ((UINT)*path < ' ') {				/* Null path name is the origin directory itself */
+		res = dir_sdi(dp, 0);
+		dp->FATFS_DIR = 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 sagment 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, */
+						dp->sclust = 0; dp->FATFS_DIR = 0;	/* it is the root directory and stay there */
+						if (!(ns & NS_LAST)) continue;	/* Continue to follow if not last segment */
+						res = FR_OK;					/* Ended at the root directroy. Function completed. */
+					} 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. */
+			FATFS_DIR = dp->FATFS_DIR;						/* Follow the sub-directory */
+			if (!(FATFS_DIR[DIR_Attr] & AM_DIR)) {	/* It is not a sub-directory and cannot follow */
+				res = FR_NO_PATH; break;
+			}
+			dp->sclust = ld_clust(dp->fs, FATFS_DIR);
+		}
+	}
+
+	return res;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Load a sector and check if it is an FAT Volume Boot Record            */
+/* Get logical drive number from path name                               */
 /*-----------------------------------------------------------------------*/
 
 static
-BYTE check_fs ( /* 0:FAT-VBR, 1:Any BR but not FAT, 2:Not a BR, 3:Disk error */
-    FATFS *fs,  /* File system object */
-    DWORD sect  /* Sector# (lba) to check if it is an FAT boot record or not */
+int get_ldnumber (		/* Returns logical drive number (-1:invalid drive) */
+	const TCHAR** path	/* Pointer to pointer to the path name */
 )
 {
-    if (disk_read(fs->drv, fs->win, sect, 1) != RES_OK) /* Load boot record */
-        return 3;
-    if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)       /* Check record signature (always placed at offset 510 even if the sector size is >512) */
-        return 2;
-
-    if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146) /* Check "FAT" string */
-        return 0;
-    if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)
-        return 0;
-
-    return 1;
+	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 && _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 boor sector, 1:Valid boor sector but not FAT, 2:Not a boot sector, 3:Disk error */
+	FATFS* fs,	/* File system object */
+	DWORD sect	/* Sector# (lba) to check if it is an FAT boot record or not */
+)
+{
+	fs->wflag = 0; fs->winsect = 0xFFFFFFFF;	/* Invaidate window */
+	if (move_window(fs, sect) != FR_OK)			/* Load boot record */
+		return 3;
+
+	if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)	/* Check boot record signature (always placed at offset 510 even if the sector size is >512) */
+		return 2;
+
+	if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146)		/* Check "FAT" string */
+		return 0;
+	if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)	/* Check "FAT" string */
+		return 0;
+
+	return 1;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Check if the file system object is valid or not                       */
+/* Find logical drive and check if the volume is mounted                 */
 /*-----------------------------------------------------------------------*/
 
 static
-FRESULT chk_mounted (   /* 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 wmode          /* !=0: Check write protection for write access */
+FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
+	FATFS** rfs,		/* Pointer to pointer to the found file system object */
+	const TCHAR** path,	/* Pointer to pointer to the path name (drive number) */
+	BYTE wmode			/* !=0: Check write protection for write access */
 )
 {
-    BYTE fmt, b, pi, *tbl;
-    UINT vol;
-    DSTATUS stat;
-    DWORD bsect, fasize, tsect, sysect, nclst, szbfat;
-    WORD nrsv;
-    const TCHAR *p = *path;
-    FATFS *fs;
-
-
-    /* Get logical drive number from the path name */
-    vol = p[0] - '0';                   /* Is there a drive number? */
-    if (vol <= 9 && p[1] == ':') {      /* Found a drive number, get and strip it */
-        p += 2; *path = p;              /* Return pointer to the path name */
-    } else {                            /* No drive number is given */
-#if _FS_RPATH
-        vol = CurrVol;                  /* Use current drive */
-#else
-        vol = 0;                        /* Use drive 0 */
-#endif
-    }
-
-    /* Check if the file system object is valid or not */
-    *rfs = 0;
-    if (vol >= _VOLUMES)                /* Is the drive number valid? */
-        return FR_INVALID_DRIVE;
-    fs = FatFs[vol];                    /* Get corresponding file system object */
-    if (!fs) return FR_NOT_ENABLED;     /* Is the file system object available? */
-
-    ENTER_FF(fs);                       /* Lock file system */
-
-    *rfs = fs;                          /* Return pointer to the corresponding file system object */
-    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 (has not been changed), */
-            if (!_FS_READONLY && wmode && (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 && wmode && (stat & STA_PROTECT)) /* Check disk write protection if needed */
-        return FR_WRITE_PROTECTED;
-#if _MAX_SS != 512                      /* Get disk sector size (variable sector size cfg only) */
-    if (disk_ioctl(fs->drv, GET_SECTOR_SIZE, &fs->ssize) != RES_OK)
-        return FR_DISK_ERR;
+	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 */
+
+	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 && wmode && (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 && wmode && (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
+		|| SS(fs) < _MIN_SS || SS(fs) > _MAX_SS) return FR_DISK_ERR;
 #endif
-    /* Search FAT partition on the drive. Supports only generic partitions, FDISK and SFD. */
-    fmt = check_fs(fs, bsect = 0);      /* Load sector 0 and check if it is an FAT-VBR (in SFD) */
-    if (LD2PT(vol) && !fmt) fmt = 1;    /* Force non-SFD if the volume is forced partition */
-    if (fmt == 1) {                     /* Not an FAT-VBR, the physical drive can be partitioned */
-        /* Check the partition listed in the partition table */
-        pi = LD2PT(vol);
-        if (pi) pi--;
-        tbl = &fs->win[MBR_Table + pi * SZ_PTE];/* Partition table */
-        if (tbl[4]) {                       /* Is the partition existing? */
-            bsect = LD_DWORD(&tbl[8]);      /* Partition offset in LBA */
-            fmt = check_fs(fs, bsect);      /* Check the partition */
-        }
-    }
-    if (fmt == 3) return FR_DISK_ERR;
-    if (fmt) return FR_NO_FILESYSTEM;       /* No FAT volume is found */
-
-    /* An FAT volume is found. Following code initializes the file system object */
-
-    if (LD_WORD(fs->win+BPB_BytsPerSec) != SS(fs))      /* (BPB_BytsPerSec must be equal to the physical sector size) */
-        return FR_NO_FILESYSTEM;
-
-    fasize = LD_WORD(fs->win+BPB_FATSz16);              /* Number of sectors per FAT */
-    if (!fasize) fasize = LD_DWORD(fs->win+BPB_FATSz32);
-    fs->fsize = fasize;
-
-    fs->n_fats = b = fs->win[BPB_NumFATs];              /* Number of FAT copies */
-    if (b != 1 && b != 2) return FR_NO_FILESYSTEM;      /* (Must be 1 or 2) */
-    fasize *= b;                                        /* Number of sectors for FAT area */
-
-    fs->csize = b = fs->win[BPB_SecPerClus];            /* Number of sectors per cluster */
-    if (!b || (b & (b - 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) / SZ_DIR)) return FR_NO_FILESYSTEM; /* (BPB_RootEntCnt must be sector aligned) */
-
-    tsect = LD_WORD(fs->win+BPB_TotSec16);              /* Number of sectors on the volume */
-    if (!tsect) tsect = LD_DWORD(fs->win+BPB_TotSec32);
-
-    nrsv = LD_WORD(fs->win+BPB_RsvdSecCnt);             /* Number of reserved sectors */
-    if (!nrsv) return FR_NO_FILESYSTEM;                 /* (BPB_RsvdSecCnt must not be 0) */
-
-    /* Determine the FAT sub type */
-    sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZ_DIR); /* RSV+FAT+DIR */
-    if (tsect < sysect) return FR_NO_FILESYSTEM;        /* (Invalid volume size) */
-    nclst = (tsect - sysect) / fs->csize;               /* Number of clusters */
-    if (!nclst) return FR_NO_FILESYSTEM;                /* (Invalid volume size) */
-    fmt = FS_FAT12;
-    if (nclst >= MIN_FAT16) fmt = FS_FAT16;
-    if (nclst >= MIN_FAT32) fmt = FS_FAT32;
-
-    /* Boundaries and Limits */
-    fs->n_fatent = nclst + 2;                           /* Number of FAT entries */
-    fs->database = bsect + sysect;                      /* Data start sector */
-    fs->fatbase = bsect + nrsv;                         /* FAT start sector */
-    if (fmt == FS_FAT32) {
-        if (fs->n_rootdir) return FR_NO_FILESYSTEM;     /* (BPB_RootEntCnt must be 0) */
-        fs->dirbase = LD_DWORD(fs->win+BPB_RootClus);   /* Root directory start cluster */
-        szbfat = fs->n_fatent * 4;                      /* (Required FAT size) */
-    } else {
-        if (!fs->n_rootdir) return FR_NO_FILESYSTEM;    /* (BPB_RootEntCnt must not be 0) */
-        fs->dirbase = fs->fatbase + fasize;             /* Root directory start sector */
-        szbfat = (fmt == FS_FAT16) ?                    /* (Required FAT size) */
-            fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
-    }
-    if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs))   /* (BPB_FATSz must not be less than required) */
-        return FR_NO_FILESYSTEM;
+	/* 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 boot sector as SFD */
+	if (fmt == 1 || (!fmt && (LD2PT(vol)))) {	/* Not an FAT boot sector or forced partition number */
+		for (i = 0; i < 4; i++) {			/* Get partition offset */
+			pt = fs->win + MBR_Table + i * SZ_PTE;
+			br[i] = pt[4] ? LD_DWORD(&pt[8]) : 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) : 2;	/* Check the partition */
+		} while (!LD2PT(vol) && fmt && ++i < 4);
+	}
+	if (fmt == 3) return FR_DISK_ERR;		/* An error occured in the disk I/O layer */
+	if (fmt) return FR_NO_FILESYSTEM;		/* No FAT volume is found */
+
+	/* An FAT volume is found. Following code initializes the file system object */
+
+	if (LD_WORD(fs->win + BPB_BytsPerSec) != SS(fs))	/* (BPB_BytsPerSec must be equal to the physical sector size) */
+		return FR_NO_FILESYSTEM;
+
+	fasize = LD_WORD(fs->win + BPB_FATSz16);			/* Number of sectors per FAT */
+	if (!fasize) fasize = LD_DWORD(fs->win + BPB_FATSz32);
+	fs->fsize = fasize;
+
+	fs->n_fats = fs->win[BPB_NumFATs];					/* Number of FAT copies */
+	if (fs->n_fats != 1 && fs->n_fats != 2)				/* (Must be 1 or 2) */
+		return FR_NO_FILESYSTEM;
+	fasize *= fs->n_fats;								/* Number of sectors for FAT area */
+
+	fs->csize = fs->win[BPB_SecPerClus];				/* Number of sectors per cluster */
+	if (!fs->csize || (fs->csize & (fs->csize - 1)))	/* (Must be power of 2) */
+		return FR_NO_FILESYSTEM;
+
+	fs->n_rootdir = LD_WORD(fs->win + BPB_RootEntCnt);	/* Number of root directory entries */
+	if (fs->n_rootdir % (SS(fs) / SZ_DIRE))				/* (Must be sector aligned) */
+		return FR_NO_FILESYSTEM;
+
+	tsect = LD_WORD(fs->win + BPB_TotSec16);			/* Number of sectors on the volume */
+	if (!tsect) tsect = LD_DWORD(fs->win + BPB_TotSec32);
+
+	nrsv = LD_WORD(fs->win + BPB_RsvdSecCnt);			/* Number of reserved sectors */
+	if (!nrsv) return FR_NO_FILESYSTEM;					/* (Must not be 0) */
+
+	/* Determine the FAT sub type */
+	sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZ_DIRE);	/* RSV + FAT + FATFS_DIR */
+	if (tsect < sysect) return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
+	nclst = (tsect - sysect) / fs->csize;				/* Number of clusters */
+	if (!nclst) return FR_NO_FILESYSTEM;				/* (Invalid volume size) */
+	fmt = FS_FAT12;
+	if (nclst >= MIN_FAT16) fmt = FS_FAT16;
+	if (nclst >= MIN_FAT32) fmt = FS_FAT32;
+
+	/* 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 (fs->n_rootdir) return FR_NO_FILESYSTEM;		/* (BPB_RootEntCnt must be 0) */
+		fs->dirbase = LD_DWORD(fs->win + BPB_RootClus);	/* Root directory start cluster */
+		szbfat = fs->n_fatent * 4;						/* (Needed FAT size) */
+	} else {
+		if (!fs->n_rootdir)	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))	/* (BPB_FATSz must not be less than the size needed) */
+		return FR_NO_FILESYSTEM;
 
 #if !_FS_READONLY
-    /* Initialize cluster allocation information */
-    fs->free_clust = 0xFFFFFFFF;
-    fs->last_clust = 0;
-
-    /* Get fsinfo if available */
-    if (fmt == FS_FAT32) {
-        fs->fsi_flag = 0;
-        fs->fsi_sector = bsect + LD_WORD(fs->win+BPB_FSInfo);
-        if (disk_read(fs->drv, fs->win, fs->fsi_sector, 1) == RES_OK &&
-            LD_WORD(fs->win+BS_55AA) == 0xAA55 &&
-            LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 &&
-            LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) {
-                fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free);
-                fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count);
-        }
-    }
+	/* Initialize cluster allocation information */
+	fs->last_clust = fs->free_clust = 0xFFFFFFFF;
+
+	/* Get fsinfo if available */
+	fs->fsi_flag = 0x80;
+#if (_FS_NOFSINFO & 3) != 3
+	if (fmt == FS_FAT32				/* Enable FSINFO only if FAT32 and BPB_FSInfo is 1 */
+		&& LD_WORD(fs->win + BPB_FSInfo) == 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_clust = LD_DWORD(fs->win + FSI_Free_Count);
 #endif
-    fs->fs_type = fmt;      /* FAT sub-type */
-    fs->id = ++Fsid;        /* File system mount ID */
-    fs->winsect = 0;        /* Invalidate sector cache */
-    fs->wflag = 0;
+#if (_FS_NOFSINFO & 2) == 0
+			fs->last_clust = LD_DWORD(fs->win + FSI_Nxt_Free);
+#endif
+		}
+	}
+#endif
+#endif
+	fs->fs_type = fmt;	/* FAT sub-type */
+	fs->id = ++Fsid;	/* File system mount ID */
 #if _FS_RPATH
-    fs->cdir = 0;           /* Current directory (root dir) */
+	fs->cdir = 0;		/* Set current directory to root */
 #endif
-#if _FS_LOCK                /* Clear file lock semaphores */
-    clear_lock(fs);
+#if _FS_LOCK			/* Clear file lock semaphores */
+	clear_lock(fs);
 #endif
 
-    return FR_OK;
+	return FR_OK;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Check if the file/dir object is valid or not                          */
+/* Check if the file/directory object is valid or not                    */
 /*-----------------------------------------------------------------------*/
 
 static
-FRESULT validate (  /* FR_OK(0): The object is valid, !=0: Invalid */
-    void* obj       /* Pointer to the object FIL/DIR to check validity */
+FRESULT validate (	/* FR_OK(0): The object is valid, !=0: Invalid */
+	void* obj		/* Pointer to the object FIL/FATFS_DIR to check validity */
 )
 {
-    FIL *fil;
-
-
-    fil = (FIL*)obj;    /* Assuming offset of fs and id in the FIL/DIR is identical */
-    if (!fil->fs || !fil->fs->fs_type || fil->fs->id != fil->id)
-        return FR_INVALID_OBJECT;
-
-    ENTER_FF(fil->fs);      /* Lock file system */
-
-    if (disk_status(fil->fs->drv) & STA_NOINIT)
-        return FR_NOT_READY;
-
-    return FR_OK;
+	FIL *fil = (FIL*)obj;	/* Assuming offset of .fs and .id in the FIL/FATFS_DIR structure is identical */
+
+
+	if (!fil || !fil->fs || !fil->fs->fs_type || fil->fs->id != fil->id)
+		return FR_INVALID_OBJECT;
+
+	ENTER_FF(fil->fs);		/* Lock file system */
+
+	if (disk_status(fil->fs->drv) & STA_NOINIT)
+		return FR_NOT_READY;
+
+	return FR_OK;
 }
 
 
@@ -2242,36 +2356,43 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_mount (
-    BYTE vol,       /* Logical drive number to be mounted/unmounted */
-    FATFS *fs       /* Pointer to new file system object (NULL for unmount)*/
+	FATFS* fs,			/* Pointer to the file system object (NULL:unmount)*/
+	const TCHAR* path,	/* Logical drive number to be mounted/unmounted */
+	BYTE opt			/* 0:Do not mount (delayed mount), 1:Mount immediately */
 )
 {
-    FATFS *rfs;
-
-
-    if (vol >= _VOLUMES)        /* Check if the drive number is valid */
-        return FR_INVALID_DRIVE;
-    rfs = FatFs[vol];           /* Get current fs object */
-
-    if (rfs) {
+	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
-        clear_lock(rfs);
+		clear_lock(cfs);
 #endif
-#if _FS_REENTRANT               /* Discard sync object of the current volume */
-        if (!ff_del_syncobj(rfs->sobj)) return FR_INT_ERR;
+#if _FS_REENTRANT						/* Discard sync object of the current volume */
+		if (!ff_del_syncobj(cfs->sobj)) return FR_INT_ERR;
 #endif
-        rfs->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(vol, &fs->sobj)) return FR_INT_ERR;
+		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 */
-
-    return FR_OK;
+	}
+	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(&fs, &path, 0);	/* Force mounted the volume */
+	LEAVE_FF(fs, res);
 }
 
 
@@ -2282,128 +2403,132 @@
 /*-----------------------------------------------------------------------*/
 
 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 */
+	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;
-    FATFS_DIR dj;
-    BYTE *dir;
-    DEF_NAMEBUF;
-
-
-    if (!fp) return FR_INVALID_OBJECT;
-    fp->fs = 0;         /* Clear file object */
-
+	FRESULT res;
+	FATFS_DIR dj;
+	BYTE *FATFS_DIR;
+	DEFINE_NAMEBUF;
 #if !_FS_READONLY
-    mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
-    res = chk_mounted(&path, &dj.fs, (BYTE)(mode & ~FA_READ));
+	DWORD dw, cl;
+#endif
+
+
+	if (!fp) return FR_INVALID_OBJECT;
+	fp->fs = 0;			/* Clear file object */
+
+	/* Get logical drive number */
+#if !_FS_READONLY
+	mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
+	res = find_volume(&dj.fs, &path, (BYTE)(mode & ~FA_READ));
 #else
-    mode &= FA_READ;
-    res = chk_mounted(&path, &dj.fs, 0);
+	mode &= FA_READ;
+	res = find_volume(&dj.fs, &path, 0);
 #endif
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);   /* Follow the file path */
-        dir = dj.dir;
-#if !_FS_READONLY   /* R/W configuration */
-        if (res == FR_OK) {
-            if (!dir)   /* Current dir itself */
-                res = FR_INVALID_NAME;
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		FATFS_DIR = dj.FATFS_DIR;
+#if !_FS_READONLY	/* R/W configuration */
+		if (res == FR_OK) {
+			if (!FATFS_DIR)	/* Default directory itself */
+				res = FR_INVALID_NAME;
 #if _FS_LOCK
-            else
-                res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 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)) {
-            DWORD dw, cl;
-
-            if (res != FR_OK) {                 /* No file, create new */
-                if (res == FR_NO_FILE)          /* There is no file to open, create a new entry */
+		}
+		/* 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
-                    res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
+					res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
 #else
-                    res = dir_register(&dj);
+					res = dir_register(&dj);
 #endif
-                mode |= FA_CREATE_ALWAYS;       /* File is created */
-                dir = dj.dir;                   /* New entry */
-            }
-            else {                              /* Any object is already existing */
-                if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) {    /* Cannot overwrite it (R/O or DIR) */
-                    res = FR_DENIED;
-                } else {
-                    if (mode & FA_CREATE_NEW)   /* Cannot create as new file */
-                        res = FR_EXIST;
-                }
-            }
-            if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {    /* Truncate it if overwrite mode */
-                dw = get_fattime();                 /* Created time */
-                ST_DWORD(dir+DIR_CrtTime, dw);
-                dir[DIR_Attr] = 0;                  /* Reset attribute */
-                ST_DWORD(dir+DIR_FileSize, 0);      /* size = 0 */
-                cl = ld_clust(dj.fs, dir);          /* Get start cluster */
-                st_clust(dir, 0);                   /* cluster = 0 */
-                dj.fs->wflag = 1;
-                if (cl) {                           /* Remove the cluster chain if exist */
-                    dw = dj.fs->winsect;
-                    res = remove_chain(dj.fs, cl);
-                    if (res == FR_OK) {
-                        dj.fs->last_clust = cl - 1; /* Reuse the cluster hole */
-                        res = move_window(dj.fs, dw);
-                    }
-                }
-            }
-        }
-        else {  /* Open an existing file */
-            if (res == FR_OK) {                     /* Follow succeeded */
-                if (dir[DIR_Attr] & AM_DIR) {       /* It is a directory */
-                    res = FR_NO_FILE;
-                } else {
-                    if ((mode & FA_WRITE) && (dir[DIR_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__WRITTEN;
-            fp->dir_sect = dj.fs->winsect;          /* Pointer to the directory entry */
-            fp->dir_ptr = dir;
+				mode |= FA_CREATE_ALWAYS;		/* File is created */
+				FATFS_DIR = dj.FATFS_DIR;					/* New entry */
+			}
+			else {								/* Any object is already existing */
+				if (FATFS_DIR[DIR_Attr] & (AM_RDO | AM_DIR)) {	/* Cannot overwrite it (R/O or FATFS_DIR) */
+					res = FR_DENIED;
+				} else {
+					if (mode & FA_CREATE_NEW)	/* Cannot create as new file */
+						res = FR_EXIST;
+				}
+			}
+			if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {	/* Truncate it if overwrite mode */
+				dw = GET_FATTIME();				/* Created time */
+				ST_DWORD(FATFS_DIR + DIR_CrtTime, dw);
+				FATFS_DIR[DIR_Attr] = 0;				/* Reset attribute */
+				ST_DWORD(FATFS_DIR + DIR_FileSize, 0);/* size = 0 */
+				cl = ld_clust(dj.fs, FATFS_DIR);		/* Get start cluster */
+				st_clust(FATFS_DIR, 0);				/* cluster = 0 */
+				dj.fs->wflag = 1;
+				if (cl) {						/* Remove the cluster chain if exist */
+					dw = dj.fs->winsect;
+					res = remove_chain(dj.fs, cl);
+					if (res == FR_OK) {
+						dj.fs->last_clust = cl - 1;	/* Reuse the cluster hole */
+						res = move_window(dj.fs, dw);
+					}
+				}
+			}
+		}
+		else {	/* Open an existing file */
+			if (res == FR_OK) {					/* Follow succeeded */
+				if (FATFS_DIR[DIR_Attr] & AM_DIR) {	/* It is a directory */
+					res = FR_NO_FILE;
+				} else {
+					if ((mode & FA_WRITE) && (FATFS_DIR[DIR_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__WRITTEN;
+			fp->dir_sect = dj.fs->winsect;		/* Pointer to the directory entry */
+			fp->dir_ptr = FATFS_DIR;
 #if _FS_LOCK
-            fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
-            if (!fp->lockid) res = FR_INT_ERR;
+			fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
+			if (!fp->lockid) res = FR_INT_ERR;
 #endif
-        }
-
-#else               /* R/O configuration */
-        if (res == FR_OK) {                 /* Follow succeeded */
-            dir = dj.dir;
-            if (!dir) {                     /* Current dir itself */
-                res = FR_INVALID_NAME;
-            } else {
-                if (dir[DIR_Attr] & AM_DIR) /* It is a directory */
-                    res = FR_NO_FILE;
-            }
-        }
+		}
+
+#else				/* R/O configuration */
+		if (res == FR_OK) {					/* Follow succeeded */
+			FATFS_DIR = dj.FATFS_DIR;
+			if (!FATFS_DIR) {						/* Current directory itself */
+				res = FR_INVALID_NAME;
+			} else {
+				if (FATFS_DIR[DIR_Attr] & AM_DIR)	/* It is a directory */
+					res = FR_NO_FILE;
+			}
+		}
 #endif
-        FREE_BUF();
-
-        if (res == FR_OK) {
-            fp->flag = mode;                    /* File access mode */
-            fp->sclust = ld_clust(dj.fs, dir);  /* File start cluster */
-            fp->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
-            fp->fptr = 0;                       /* File pointer */
-            fp->dsect = 0;
+		FREE_BUF();
+
+		if (res == FR_OK) {
+			fp->flag = mode;					/* File access mode */
+			fp->err = 0;						/* Clear error flag */
+			fp->sclust = ld_clust(dj.fs, FATFS_DIR);	/* File start cluster */
+			fp->fsize = LD_DWORD(FATFS_DIR + DIR_FileSize);	/* File size */
+			fp->fptr = 0;						/* File pointer */
+			fp->dsect = 0;
 #if _USE_FASTSEEK
-            fp->cltbl = 0;                      /* Normal seek mode */
+			fp->cltbl = 0;						/* Normal seek mode */
 #endif
-            fp->fs = dj.fs; fp->id = dj.fs->id; /* Validate file object */
-        }
-    }
-
-    LEAVE_FF(dj.fs, res);
+			fp->fs = dj.fs;	 					/* Validate file object */
+			fp->id = fp->fs->id;
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
@@ -2414,96 +2539,96 @@
 /*-----------------------------------------------------------------------*/
 
 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 */
+	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;
-    DWORD clst, sect, remain;
-    UINT rcnt, cc;
-    BYTE csect, *rbuff = (BYTE *)buff;
-
-
-    *br = 0;    /* Clear read byte counter */
-
-    res = validate(fp);                         /* Check validity */
-    if (res != FR_OK) LEAVE_FF(fp->fs, res);
-    if (fp->flag & FA__ERROR)                   /* Aborted file? */
-        LEAVE_FF(fp->fs, FR_INT_ERR);
-    if (!(fp->flag & FA_READ))                  /* Check access mode */
-        LEAVE_FF(fp->fs, FR_DENIED);
-    remain = fp->fsize - 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(fp->fs)) == 0) {     /* On the sector boundary? */
-            csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
-            if (!csect) {                       /* On the cluster boundary? */
-                if (fp->fptr == 0) {            /* On the top of the file? */
-                    clst = fp->sclust;          /* Follow from the origin */
-                } else {                        /* Middle or end of the file */
+	FRESULT res;
+	DWORD clst, sect, remain;
+	UINT rcnt, cc;
+	BYTE csect, *rbuff = (BYTE*)buff;
+
+
+	*br = 0;	/* Clear read byte counter */
+
+	res = validate(fp);							/* Check validity */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->err)								/* Check error */
+		LEAVE_FF(fp->fs, (FRESULT)fp->err);
+	if (!(fp->flag & FA_READ)) 					/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+	remain = fp->fsize - 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(fp->fs)) == 0) {		/* On the sector boundary? */
+			csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));	/* Sector offset in the cluster */
+			if (!csect) {						/* On the cluster boundary? */
+				if (fp->fptr == 0) {			/* On the top of the file? */
+					clst = fp->sclust;			/* Follow 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
+					if (fp->cltbl)
+						clst = clmt_clust(fp, fp->fptr);	/* Get cluster# from the CLMT */
+					else
 #endif
-                        clst = get_fat(fp->fs, fp->clust);  /* Follow cluster chain on the FAT */
-                }
-                if (clst < 2) ABORT(fp->fs, FR_INT_ERR);
-                if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
-                fp->clust = clst;               /* Update current cluster */
-            }
-            sect = clust2sect(fp->fs, fp->clust);   /* Get current sector */
-            if (!sect) ABORT(fp->fs, FR_INT_ERR);
-            sect += csect;
-            cc = btr / SS(fp->fs);              /* When remaining bytes >= sector size, */
-            if (cc) {                           /* Read maximum contiguous sectors directly */
-                if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
-                    cc = fp->fs->csize - csect;
-                if (disk_read(fp->fs->drv, rbuff, sect, (BYTE)cc) != RES_OK)
-                    ABORT(fp->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 */
+						clst = get_fat(fp->fs, fp->clust);	/* Follow cluster chain on the FAT */
+				}
+				if (clst < 2) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->clust = clst;				/* Update current cluster */
+			}
+			sect = clust2sect(fp->fs, fp->clust);	/* Get current sector */
+			if (!sect) ABORT(fp->fs, FR_INT_ERR);
+			sect += csect;
+			cc = btr / SS(fp->fs);				/* When remaining bytes >= sector size, */
+			if (cc) {							/* Read maximum contiguous sectors directly */
+				if (csect + cc > fp->fs->csize)	/* Clip at cluster boundary */
+					cc = fp->fs->csize - csect;
+				if (disk_read(fp->fs->drv, rbuff, sect, cc) != RES_OK)
+					ABORT(fp->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 (fp->fs->wflag && fp->fs->winsect - sect < cc)
-                    mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
+				if (fp->fs->wflag && fp->fs->winsect - sect < cc)
+					mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
 #else
-                if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)
-                    mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
+				if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)
+					mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
 #endif
 #endif
-                rcnt = SS(fp->fs) * cc;         /* Number of bytes transferred */
-                continue;
-            }
+				rcnt = SS(fp->fs) * cc;			/* Number of bytes transferred */
+				continue;
+			}
 #if !_FS_TINY
-            if (fp->dsect != sect) {            /* Load data sector if not in cache */
+			if (fp->dsect != sect) {			/* Load data sector if not in cache */
 #if !_FS_READONLY
-                if (fp->flag & FA__DIRTY) {     /* Write-back dirty sector cache */
-                    if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
-                        ABORT(fp->fs, FR_DISK_ERR);
-                    fp->flag &= ~FA__DIRTY;
-                }
+				if (fp->flag & FA__DIRTY) {		/* Write-back dirty sector cache */
+					if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+						ABORT(fp->fs, FR_DISK_ERR);
+					fp->flag &= ~FA__DIRTY;
+				}
 #endif
-                if (disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK) /* Fill sector cache */
-                    ABORT(fp->fs, FR_DISK_ERR);
-            }
+				if (disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)	/* Fill sector cache */
+					ABORT(fp->fs, FR_DISK_ERR);
+			}
 #endif
-            fp->dsect = sect;
-        }
-        rcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));  /* Get partial sector data from sector buffer */
-        if (rcnt > btr) rcnt = btr;
+			fp->dsect = sect;
+		}
+		rcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));	/* Get partial sector data from sector buffer */
+		if (rcnt > btr) rcnt = btr;
 #if _FS_TINY
-        if (move_window(fp->fs, fp->dsect))     /* Move sector window */
-            ABORT(fp->fs, FR_DISK_ERR);
-        mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt);  /* Pick partial sector */
+		if (move_window(fp->fs, fp->dsect) != FR_OK)		/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */
 #else
-        mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt);  /* Pick partial sector */
+		mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt);	/* Pick partial sector */
 #endif
-    }
-
-    LEAVE_FF(fp->fs, FR_OK);
+	}
+
+	LEAVE_FF(fp->fs, FR_OK);
 }
 
 
@@ -2515,175 +2640,179 @@
 /*-----------------------------------------------------------------------*/
 
 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 */
+	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;
-    DWORD clst, sect;
-    UINT wcnt, cc;
-    const BYTE *wbuff = (const BYTE *)buff;
-    BYTE csect;
-    bool need_sync = false;
-
-    *bw = 0;    /* Clear write byte counter */
-
-    res = validate(fp);                     /* Check validity */
-    if (res != FR_OK) LEAVE_FF(fp->fs, res);
-    if (fp->flag & FA__ERROR)               /* Aborted file? */
-        LEAVE_FF(fp->fs, FR_INT_ERR);
-    if (!(fp->flag & FA_WRITE))             /* Check access mode */
-        LEAVE_FF(fp->fs, FR_DENIED);
-    if ((DWORD)(fp->fsize + btw) < fp->fsize) btw = 0;  /* File size cannot reach 4GB */
-
-    for ( ;  btw;                           /* Repeat until all data written */
-        wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
-        if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
-            csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
-            if (!csect) {                   /* On the cluster boundary? */
-                if (fp->fptr == 0) {        /* On the top of the file? */
-                    clst = fp->sclust;      /* Follow from the origin */
-                    if (clst == 0)          /* When no cluster is allocated, */
-                        fp->sclust = clst = create_chain(fp->fs, 0);    /* Create a new cluster chain */
-                } else {                    /* Middle or end of the file */
+	FRESULT res;
+	DWORD clst, sect;
+	UINT wcnt, cc;
+	const BYTE *wbuff = (const BYTE*)buff;
+	BYTE csect;
+	bool need_sync = false;
+
+	*bw = 0;	/* Clear write byte counter */
+
+	res = validate(fp);						/* Check validity */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->err)							/* Check error */
+		LEAVE_FF(fp->fs, (FRESULT)fp->err);
+	if (!(fp->flag & FA_WRITE))				/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+	if (fp->fptr + btw < fp->fptr) btw = 0;	/* File size cannot reach 4GB */
+
+	for ( ;  btw;							/* Repeat until all data written */
+		wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
+		if ((fp->fptr % SS(fp->fs)) == 0) {	/* On the sector boundary? */
+			csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));	/* Sector offset in the cluster */
+			if (!csect) {					/* On the cluster boundary? */
+				if (fp->fptr == 0) {		/* On the top of the file? */
+					clst = fp->sclust;		/* Follow from the origin */
+					if (clst == 0)			/* When no cluster is allocated, */
+						clst = create_chain(fp->fs, 0);	/* Create a new cluster chain */
+				} 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
+					if (fp->cltbl)
+						clst = clmt_clust(fp, fp->fptr);	/* Get cluster# from the CLMT */
+					else
 #endif
-                        clst = create_chain(fp->fs, 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(fp->fs, FR_INT_ERR);
-                if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
-                fp->clust = clst;           /* Update current cluster */
-
+						clst = create_chain(fp->fs, 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(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->clust = clst;			/* Update current cluster */
+				if (fp->sclust == 0) fp->sclust = clst;	/* Set start cluster if the first write */
+				
 #ifdef FLUSH_ON_NEW_CLUSTER
                 // We do not need to flush for the first cluster
                 if (fp->fptr != 0) {
                     need_sync = true;
                 }
 #endif
-            }
+			}
 #if _FS_TINY
-            if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0)) /* Write-back sector cache */
-                ABORT(fp->fs, FR_DISK_ERR);
+			if (fp->fs->winsect == fp->dsect && sync_window(fp->fs))	/* Write-back sector cache */
+				ABORT(fp->fs, FR_DISK_ERR);
 #else
-            if (fp->flag & FA__DIRTY) {     /* Write-back sector cache */
-                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
-                    ABORT(fp->fs, FR_DISK_ERR);
-                fp->flag &= ~FA__DIRTY;
-            }
+			if (fp->flag & FA__DIRTY) {		/* Write-back sector cache */
+				if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
 #endif
-            sect = clust2sect(fp->fs, fp->clust);   /* Get current sector */
-            if (!sect) ABORT(fp->fs, FR_INT_ERR);
-            sect += csect;
-            cc = btw / SS(fp->fs);          /* When remaining bytes >= sector size, */
-            if (cc) {                       /* Write maximum contiguous sectors directly */
-                if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
-                    cc = fp->fs->csize - csect;
-                if (disk_write(fp->fs->drv, wbuff, sect, (BYTE)cc) != RES_OK)
-                    ABORT(fp->fs, FR_DISK_ERR);
+			sect = clust2sect(fp->fs, fp->clust);	/* Get current sector */
+			if (!sect) ABORT(fp->fs, FR_INT_ERR);
+			sect += csect;
+			cc = btw / SS(fp->fs);			/* When remaining bytes >= sector size, */
+			if (cc) {						/* Write maximum contiguous sectors directly */
+				if (csect + cc > fp->fs->csize)	/* Clip at cluster boundary */
+					cc = fp->fs->csize - csect;
+				if (disk_write(fp->fs->drv, wbuff, sect, cc) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+#if _FS_MINIMIZE <= 2
 #if _FS_TINY
-                if (fp->fs->winsect - sect < cc) {  /* Refill sector cache if it gets invalidated by the direct write */
-                    mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
-                    fp->fs->wflag = 0;
-                }
+				if (fp->fs->winsect - sect < cc) {	/* Refill sector cache if it gets invalidated by the direct write */
+					mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
+					fp->fs->wflag = 0;
+				}
 #else
-                if (fp->dsect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
-                    mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
-                    fp->flag &= ~FA__DIRTY;
-                }
+				if (fp->dsect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
+					mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
+					fp->flag &= ~FA__DIRTY;
+				}
 #endif
-                wcnt = SS(fp->fs) * cc;     /* Number of bytes transferred */
+#endif
+				wcnt = SS(fp->fs) * cc;		/* Number of bytes transferred */
 #ifdef FLUSH_ON_NEW_SECTOR
                 need_sync = true;
 #endif
-                continue;
-            }
+				continue;
+			}
 #if _FS_TINY
-            if (fp->fptr >= fp->fsize) {    /* Avoid silly cache filling at growing edge */
-                if (move_window(fp->fs, 0)) ABORT(fp->fs, FR_DISK_ERR);
-                fp->fs->winsect = sect;
-            }
+			if (fp->fptr >= fp->fsize) {	/* Avoid silly cache filling at growing edge */
+				if (sync_window(fp->fs)) ABORT(fp->fs, FR_DISK_ERR);
+				fp->fs->winsect = sect;
+			}
 #else
-            if (fp->dsect != sect) {        /* Fill sector cache with file data */
-                if (fp->fptr < fp->fsize &&
-                    disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
-                        ABORT(fp->fs, FR_DISK_ERR);
-            }
+			if (fp->dsect != sect) {		/* Fill sector cache with file data */
+				if (fp->fptr < fp->fsize &&
+					disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
+						ABORT(fp->fs, FR_DISK_ERR);
+			}
 #endif
-            fp->dsect = sect;
-        }
-        wcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));/* Put partial sector into file I/O buffer */
-        if (wcnt > btw) wcnt = btw;
+			fp->dsect = sect;
+		}
+		wcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));/* Put partial sector into file I/O buffer */
+		if (wcnt > btw) wcnt = btw;
 #if _FS_TINY
-        if (move_window(fp->fs, fp->dsect)) /* Move sector window */
-            ABORT(fp->fs, FR_DISK_ERR);
-        mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);  /* Fit partial sector */
-        fp->fs->wflag = 1;
+		if (move_window(fp->fs, fp->dsect) != FR_OK)	/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */
+		fp->fs->wflag = 1;
 #else
-        mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);  /* Fit partial sector */
-        fp->flag |= FA__DIRTY;
+		mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);	/* Fit partial sector */
+		fp->flag |= FA__DIRTY;
 #endif
-    }
-
-    if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */
-    fp->flag |= FA__WRITTEN;                        /* Set file change flag */
-
-    if (need_sync) {
+	}
+
+	if (fp->fptr > fp->fsize) fp->fsize = fp->fptr;	/* Update file size if needed */
+	fp->flag |= FA__WRITTEN;						/* Set file change flag */
+
+	if (need_sync) {
         f_sync (fp);
     }
-
-    LEAVE_FF(fp->fs, FR_OK);
+	
+	LEAVE_FF(fp->fs, FR_OK);
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Synchronize the File Object                                           */
+/* Synchronize the File                                                  */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_sync (
-    FIL *fp     /* Pointer to the file object */
+	FIL* fp		/* Pointer to the file object */
 )
 {
-    FRESULT res;
-    DWORD tim;
-    BYTE *dir;
-
-
-    res = validate(fp);                 /* Check validity of the object */
-    if (res == FR_OK) {
-        if (fp->flag & FA__WRITTEN) {   /* Has the file been written? */
-#if !_FS_TINY   /* Write-back dirty buffer */
-            if (fp->flag & FA__DIRTY) {
-                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
-                    LEAVE_FF(fp->fs, FR_DISK_ERR);
-                fp->flag &= ~FA__DIRTY;
-            }
+	FRESULT res;
+	DWORD tm;
+	BYTE *FATFS_DIR;
+
+
+	res = validate(fp);					/* Check validity of the object */
+	if (res == FR_OK) {
+		if (fp->flag & FA__WRITTEN) {	/* Has the file been written? */
+			/* Write-back dirty buffer */
+#if !_FS_TINY
+			if (fp->flag & FA__DIRTY) {
+				if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+					LEAVE_FF(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
 #endif
-            /* Update the directory entry */
-            res = move_window(fp->fs, fp->dir_sect);
-            if (res == FR_OK) {
-                dir = fp->dir_ptr;
-                dir[DIR_Attr] |= AM_ARC;                    /* Set archive bit */
-                ST_DWORD(dir+DIR_FileSize, fp->fsize);      /* Update file size */
-                st_clust(dir, fp->sclust);                  /* Update start cluster */
-                tim = get_fattime();                        /* Update updated time */
-                ST_DWORD(dir+DIR_WrtTime, tim);
-                ST_WORD(dir+DIR_LstAccDate, 0);
-                fp->flag &= ~FA__WRITTEN;
-                fp->fs->wflag = 1;
-                res = sync(fp->fs);
-            }
-        }
-    }
-
-    LEAVE_FF(fp->fs, res);
+			/* Update the directory entry */
+			res = move_window(fp->fs, fp->dir_sect);
+			if (res == FR_OK) {
+				FATFS_DIR = fp->dir_ptr;
+				FATFS_DIR[DIR_Attr] |= AM_ARC;					/* Set archive bit */
+				ST_DWORD(FATFS_DIR + DIR_FileSize, fp->fsize);	/* Update file size */
+				st_clust(FATFS_DIR, fp->sclust);					/* Update start cluster */
+				tm = GET_FATTIME();							/* Update updated time */
+				ST_DWORD(FATFS_DIR + DIR_WrtTime, tm);
+				ST_WORD(FATFS_DIR + DIR_LstAccDate, 0);
+				fp->flag &= ~FA__WRITTEN;
+				fp->fs->wflag = 1;
+				res = sync_fs(fp->fs);
+			}
+		}
+	}
+
+	LEAVE_FF(fp->fs, res);
 }
 
 #endif /* !_FS_READONLY */
@@ -2696,163 +2825,166 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_close (
-    FIL *fp     /* Pointer to the file object to be closed */
+	FIL *fp		/* Pointer to the file object to be closed */
 )
 {
-    FRESULT res;
-
-
-#if _FS_READONLY
-    res = validate(fp);
-    {
+	FRESULT res;
+
+
+#if !_FS_READONLY
+	res = f_sync(fp);					/* Flush cached data */
+	if (res == FR_OK)
+#endif
+	{
+		res = validate(fp);				/* Lock volume */
+		if (res == FR_OK) {
 #if _FS_REENTRANT
-        FATFS *fs = fp->fs;
+			FATFS *fs = fp->fs;
 #endif
-        if (res == FR_OK) fp->fs = 0;   /* Discard file object */
-        LEAVE_FF(fs, res);
-    }
-#else
-    res = f_sync(fp);       /* Flush cached data */
 #if _FS_LOCK
-    if (res == FR_OK) {     /* Decrement open counter */
+			res = dec_lock(fp->lockid);	/* Decrement file open counter */
+			if (res == FR_OK)
+#endif
+				fp->fs = 0;				/* Invalidate file object */
 #if _FS_REENTRANT
-        FATFS *fs = fp->fs;;
-        res = validate(fp);
-        if (res == FR_OK) {
-            res = dec_lock(fp->lockid);
-            unlock_fs(fs, FR_OK);
-        }
-#else
-        res = dec_lock(fp->lockid);
+			unlock_fs(fs, FR_OK);		/* Unlock volume */
 #endif
-    }
-#endif
-    if (res == FR_OK) fp->fs = 0;   /* Discard file object */
-    return res;
-#endif
+		}
+	}
+	return res;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Current Drive/Directory Handlings                                     */
+/* Change Current Directory or Current Drive, Get Current Directory      */
 /*-----------------------------------------------------------------------*/
 
 #if _FS_RPATH >= 1
-
+#if _VOLUMES >= 2
 FRESULT f_chdrive (
-    BYTE drv        /* Drive number */
+	const TCHAR* path		/* Drive number */
 )
 {
-    if (drv >= _VOLUMES) return FR_INVALID_DRIVE;
-
-    CurrVol = drv;
-
-    return FR_OK;
+	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 */
+	const TCHAR* path	/* Pointer to the directory path */
 )
 {
-    FRESULT res;
-    DIR dj;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 0);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);       /* Follow the path */
-        FREE_BUF();
-        if (res == FR_OK) {                 /* Follow completed */
-            if (!dj.dir) {
-                dj.fs->cdir = dj.sclust;    /* Start directory itself */
-            } else {
-                if (dj.dir[DIR_Attr] & AM_DIR)  /* Reached to the directory */
-                    dj.fs->cdir = ld_clust(dj.fs, dj.dir);
-                else
-                    res = FR_NO_PATH;       /* Reached but a file */
-            }
-        }
-        if (res == FR_NO_FILE) res = FR_NO_PATH;
-    }
-
-    LEAVE_FF(dj.fs, res);
+	FRESULT res;
+	FATFS_DIR dj;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 0);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		res = follow_path(&dj, path);		/* Follow the path */
+		FREE_BUF();
+		if (res == FR_OK) {					/* Follow completed */
+			if (!dj.FATFS_DIR) {
+				dj.fs->cdir = dj.sclust;	/* Start directory itself */
+			} else {
+				if (dj.FATFS_DIR[DIR_Attr] & AM_DIR)	/* Reached to the directory */
+					dj.fs->cdir = ld_clust(dj.fs, dj.FATFS_DIR);
+				else
+					res = FR_NO_PATH;		/* Reached but a file */
+			}
+		}
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
 #if _FS_RPATH >= 2
 FRESULT f_getcwd (
-    TCHAR *path,    /* Pointer to the directory path */
-    UINT sz_path    /* Size of path */
+	TCHAR* buff,	/* Pointer to the directory path */
+	UINT len		/* Size of path */
 )
 {
-    FRESULT res;
-    DIR dj;
-    UINT i, n;
-    DWORD ccl;
-    TCHAR *tp;
-    FILINFO fno;
-    DEF_NAMEBUF;
-
-
-    *path = 0;
-    res = chk_mounted((const TCHAR**)&path, &dj.fs, 0); /* Get current volume */
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        i = sz_path;        /* Bottom of buffer (dir stack base) */
-        dj.sclust = dj.fs->cdir;            /* Start to follow upper dir from current dir */
-        while ((ccl = dj.sclust) != 0) {    /* Repeat while current dir is a sub-dir */
-            res = dir_sdi(&dj, 1);          /* Get parent dir */
-            if (res != FR_OK) break;
-            res = dir_read(&dj);
-            if (res != FR_OK) break;
-            dj.sclust = ld_clust(dj.fs, dj.dir);    /* Goto parent dir */
-            res = dir_sdi(&dj, 0);
-            if (res != FR_OK) break;
-            do {                            /* Find the entry links to the child dir */
-                res = dir_read(&dj);
-                if (res != FR_OK) break;
-                if (ccl == ld_clust(dj.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;
+	FRESULT res;
+	FATFS_DIR dj;
+	UINT i, n;
+	DWORD ccl;
+	TCHAR *tp;
+	FILINFO fno;
+	DEFINE_NAMEBUF;
+
+
+	*buff = 0;
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, (const TCHAR**)&buff, 0);	/* Get current volume */
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		i = len;			/* Bottom of buffer (directory stack base) */
+		dj.sclust = dj.fs->cdir;			/* Start to follow upper directory from current directory */
+		while ((ccl = dj.sclust) != 0) {	/* Repeat while current directory is a sub-directory */
+			res = dir_sdi(&dj, 1);			/* Get parent directory */
+			if (res != FR_OK) break;
+			res = dir_read(&dj, 0);
+			if (res != FR_OK) break;
+			dj.sclust = ld_clust(dj.fs, dj.FATFS_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(dj.fs, dj.FATFS_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;
 #if _USE_LFN
-            fno.lfname = path;
-            fno.lfsize = i;
+			fno.lfname = buff;
+			fno.lfsize = i;
+#endif
+			get_fileinfo(&dj, &fno);		/* Get the directory name and push it to the buffer */
+			tp = fno.fname;
+#if _USE_LFN
+			if (*buff) tp = buff;
 #endif
-            get_fileinfo(&dj, &fno);        /* Get the dir name and push it to the buffer */
-            tp = fno.fname;
-            if (_USE_LFN && *path) tp = path;
-            for (n = 0; tp[n]; n++) ;
-            if (i < n + 3) {
-                res = FR_NOT_ENOUGH_CORE; break;
-            }
-            while (n) path[--i] = tp[--n];
-            path[--i] = '/';
-        }
-        tp = path;
-        if (res == FR_OK) {
-            *tp++ = '0' + CurrVol;          /* Put drive number */
-            *tp++ = ':';
-            if (i == sz_path) {             /* Root-dir */
-                *tp++ = '/';
-            } else {                        /* Sub-dir */
-                do      /* Add stacked path str */
-                    *tp++ = path[i++];
-                while (i < sz_path);
-            }
-        }
-        *tp = 0;
-        FREE_BUF();
-    }
-
-    LEAVE_FF(dj.fs, res);
+			for (n = 0; tp[n]; n++) ;
+			if (i < n + 3) {
+				res = FR_NOT_ENOUGH_CORE; break;
+			}
+			while (n) buff[--i] = tp[--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_BUF();
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 #endif /* _FS_RPATH >= 2 */
 #endif /* _FS_RPATH >= 1 */
@@ -2865,154 +2997,154 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_lseek (
-    FIL *fp,        /* Pointer to the file object */
-    DWORD ofs       /* File pointer from top of file */
+	FIL* fp,		/* Pointer to the file object */
+	DWORD ofs		/* File pointer from top of file */
 )
 {
-    FRESULT res;
-
-
-    res = validate(fp);                 /* Check validity of the object */
-    if (res != FR_OK) LEAVE_FF(fp->fs, res);
-    if (fp->flag & FA__ERROR)           /* Check abort flag */
-        LEAVE_FF(fp->fs, FR_INT_ERR);
+	FRESULT res;
+	DWORD clst, bcs, nsect, ifptr;
+#if _USE_FASTSEEK
+	DWORD cl, pcl, ncl, tcl, dsc, tlen, ulen, *tbl;
+#endif
+
+
+	res = validate(fp);					/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->err)						/* Check error */
+		LEAVE_FF(fp->fs, (FRESULT)fp->err);
 
 #if _USE_FASTSEEK
-    if (fp->cltbl) {    /* Fast seek */
-        DWORD cl, pcl, ncl, tcl, dsc, tlen, ulen, *tbl;
-
-        if (ofs == CREATE_LINKMAP) {    /* Create CLMT */
-            tbl = fp->cltbl;
-            tlen = *tbl++; ulen = 2;    /* Given table size and required table size */
-            cl = fp->sclust;            /* Top 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->fs, cl);
-                        if (cl <= 1) ABORT(fp->fs, FR_INT_ERR);
-                        if (cl == 0xFFFFFFFF) ABORT(fp->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 < fp->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->fsize)        /* Clip offset at the file size */
-                ofs = fp->fsize;
-            fp->fptr = ofs;             /* Set file pointer */
-            if (ofs) {
-                fp->clust = clmt_clust(fp, ofs - 1);
-                dsc = clust2sect(fp->fs, fp->clust);
-                if (!dsc) ABORT(fp->fs, FR_INT_ERR);
-                dsc += (ofs - 1) / SS(fp->fs) & (fp->fs->csize - 1);
-                if (fp->fptr % SS(fp->fs) && dsc != fp->dsect) {    /* Refill sector cache if needed */
+	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->sclust;			/* Top 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->fs, cl);
+						if (cl <= 1) ABORT(fp->fs, FR_INT_ERR);
+						if (cl == 0xFFFFFFFF) ABORT(fp->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 < fp->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->fsize)		/* Clip offset at the file size */
+				ofs = fp->fsize;
+			fp->fptr = ofs;				/* Set file pointer */
+			if (ofs) {
+				fp->clust = clmt_clust(fp, ofs - 1);
+				dsc = clust2sect(fp->fs, fp->clust);
+				if (!dsc) ABORT(fp->fs, FR_INT_ERR);
+				dsc += (ofs - 1) / SS(fp->fs) & (fp->fs->csize - 1);
+				if (fp->fptr % SS(fp->fs) && dsc != fp->dsect) {	/* Refill sector cache if needed */
 #if !_FS_TINY
 #if !_FS_READONLY
-                    if (fp->flag & FA__DIRTY) {     /* Write-back dirty sector cache */
-                        if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
-                            ABORT(fp->fs, FR_DISK_ERR);
-                        fp->flag &= ~FA__DIRTY;
-                    }
+					if (fp->flag & FA__DIRTY) {		/* Write-back dirty sector cache */
+						if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+							ABORT(fp->fs, FR_DISK_ERR);
+						fp->flag &= ~FA__DIRTY;
+					}
 #endif
-                    if (disk_read(fp->fs->drv, fp->buf, dsc, 1) != RES_OK)  /* Load current sector */
-                        ABORT(fp->fs, FR_DISK_ERR);
+					if (disk_read(fp->fs->drv, fp->buf, dsc, 1) != RES_OK)	/* Load current sector */
+						ABORT(fp->fs, FR_DISK_ERR);
 #endif
-                    fp->dsect = dsc;
-                }
-            }
-        }
-    } else
+					fp->dsect = dsc;
+				}
+			}
+		}
+	} else
 #endif
 
-    /* Normal Seek */
-    {
-        DWORD clst, bcs, nsect, ifptr;
-
-        if (ofs > fp->fsize                 /* In read-only mode, clip offset with the file size */
+	/* Normal Seek */
+	{
+		if (ofs > fp->fsize					/* In read-only mode, clip offset with the file size */
 #if !_FS_READONLY
-             && !(fp->flag & FA_WRITE)
+			 && !(fp->flag & FA_WRITE)
 #endif
-            ) ofs = fp->fsize;
-
-        ifptr = fp->fptr;
-        fp->fptr = nsect = 0;
-        if (ofs) {
-            bcs = (DWORD)fp->fs->csize * SS(fp->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->sclust;                      /* start from the first cluster */
+			) ofs = fp->fsize;
+
+		ifptr = fp->fptr;
+		fp->fptr = nsect = 0;
+		if (ofs) {
+			bcs = (DWORD)fp->fs->csize * SS(fp->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->sclust;						/* start from the first cluster */
 #if !_FS_READONLY
-                if (clst == 0) {                        /* If no cluster chain, create a new chain */
-                    clst = create_chain(fp->fs, 0);
-                    if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
-                    if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
-                    fp->sclust = clst;
-                }
+				if (clst == 0) {						/* If no cluster chain, create a new chain */
+					clst = create_chain(fp->fs, 0);
+					if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
+					if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+					fp->sclust = clst;
+				}
 #endif
-                fp->clust = clst;
-            }
-            if (clst != 0) {
-                while (ofs > bcs) {                     /* Cluster following loop */
+				fp->clust = clst;
+			}
+			if (clst != 0) {
+				while (ofs > bcs) {						/* Cluster following loop */
 #if !_FS_READONLY
-                    if (fp->flag & FA_WRITE) {          /* Check if in write mode or not */
-                        clst = create_chain(fp->fs, clst);  /* Force stretch if in write mode */
-                        if (clst == 0) {                /* When disk gets full, clip file size */
-                            ofs = bcs; break;
-                        }
-                    } else
+					if (fp->flag & FA_WRITE) {			/* Check if in write mode or not */
+						clst = create_chain(fp->fs, clst);	/* Force stretch if in write mode */
+						if (clst == 0) {				/* When disk gets full, clip file size */
+							ofs = bcs; break;
+						}
+					} else
 #endif
-                        clst = get_fat(fp->fs, clst);   /* Follow cluster chain if not in write mode */
-                    if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
-                    if (clst <= 1 || clst >= fp->fs->n_fatent) ABORT(fp->fs, FR_INT_ERR);
-                    fp->clust = clst;
-                    fp->fptr += bcs;
-                    ofs -= bcs;
-                }
-                fp->fptr += ofs;
-                if (ofs % SS(fp->fs)) {
-                    nsect = clust2sect(fp->fs, clst);   /* Current sector */
-                    if (!nsect) ABORT(fp->fs, FR_INT_ERR);
-                    nsect += ofs / SS(fp->fs);
-                }
-            }
-        }
-        if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {  /* Fill sector cache if needed */
+						clst = get_fat(fp->fs, clst);	/* Follow cluster chain if not in write mode */
+					if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+					if (clst <= 1 || clst >= fp->fs->n_fatent) ABORT(fp->fs, FR_INT_ERR);
+					fp->clust = clst;
+					fp->fptr += bcs;
+					ofs -= bcs;
+				}
+				fp->fptr += ofs;
+				if (ofs % SS(fp->fs)) {
+					nsect = clust2sect(fp->fs, clst);	/* Current sector */
+					if (!nsect) ABORT(fp->fs, FR_INT_ERR);
+					nsect += ofs / SS(fp->fs);
+				}
+			}
+		}
+		if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {	/* Fill sector cache if needed */
 #if !_FS_TINY
 #if !_FS_READONLY
-            if (fp->flag & FA__DIRTY) {         /* Write-back dirty sector cache */
-                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
-                    ABORT(fp->fs, FR_DISK_ERR);
-                fp->flag &= ~FA__DIRTY;
-            }
+			if (fp->flag & FA__DIRTY) {			/* Write-back dirty sector cache */
+				if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+					ABORT(fp->fs, FR_DISK_ERR);
+				fp->flag &= ~FA__DIRTY;
+			}
 #endif
-            if (disk_read(fp->fs->drv, fp->buf, nsect, 1) != RES_OK)    /* Fill sector cache */
-                ABORT(fp->fs, FR_DISK_ERR);
+			if (disk_read(fp->fs->drv, fp->buf, nsect, 1) != RES_OK)	/* Fill sector cache */
+				ABORT(fp->fs, FR_DISK_ERR);
 #endif
-            fp->dsect = nsect;
-        }
+			fp->dsect = nsect;
+		}
 #if !_FS_READONLY
-        if (fp->fptr > fp->fsize) {         /* Set file change flag if the file size is extended */
-            fp->fsize = fp->fptr;
-            fp->flag |= FA__WRITTEN;
-        }
+		if (fp->fptr > fp->fsize) {			/* Set file change flag if the file size is extended */
+			fp->fsize = fp->fptr;
+			fp->flag |= FA__WRITTEN;
+		}
 #endif
-    }
-
-    LEAVE_FF(fp->fs, res);
+	}
+
+	LEAVE_FF(fp->fs, res);
 }
 
 
@@ -3023,118 +3155,213 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_opendir (
-    FATFS_DIR *dj,            /* Pointer to directory object to create */
-    const TCHAR *path   /* Pointer to the directory path */
+	FATFS_DIR* dp,			/* Pointer to directory object to create */
+	const TCHAR* path	/* Pointer to the directory path */
 )
 {
-    FRESULT res;
-    FATFS *fs;
-    DEF_NAMEBUF;
-
-
-    if (!dj) return FR_INVALID_OBJECT;
-
-    res = chk_mounted(&path, &dj->fs, 0);
-    fs = dj->fs;
-    if (res == FR_OK) {
-        INIT_BUF(*dj);
-        res = follow_path(dj, path);            /* Follow the path to the directory */
-        FREE_BUF();
-        if (res == FR_OK) {                     /* Follow completed */
-            if (dj->dir) {                      /* It is not the root dir */
-                if (dj->dir[DIR_Attr] & AM_DIR) {   /* The object is a directory */
-                    dj->sclust = ld_clust(fs, dj->dir);
-                } else {                        /* The object is not a directory */
-                    res = FR_NO_PATH;
-                }
-            }
-            if (res == FR_OK) {
-                dj->id = fs->id;
-                res = dir_sdi(dj, 0);           /* Rewind dir */
-            }
-        }
-        if (res == FR_NO_FILE) res = FR_NO_PATH;
-        if (res != FR_OK) dj->fs = 0;           /* Invalidate the dir object if function faild */
-    } else {
-        dj->fs = 0;
-    }
-
-    LEAVE_FF(fs, res);
+	FRESULT res;
+	FATFS* fs;
+	DEFINE_NAMEBUF;
+
+
+	if (!dp) return FR_INVALID_OBJECT;
+
+	/* Get logical drive number */
+	res = find_volume(&fs, &path, 0);
+	if (res == FR_OK) {
+		dp->fs = fs;
+		INIT_BUF(*dp);
+		res = follow_path(dp, path);			/* Follow the path to the directory */
+		FREE_BUF();
+		if (res == FR_OK) {						/* Follow completed */
+			if (dp->FATFS_DIR) {						/* It is not the origin directory itself */
+				if (dp->FATFS_DIR[DIR_Attr] & AM_DIR)	/* The object is a sub directory */
+					dp->sclust = ld_clust(fs, dp->FATFS_DIR);
+				else							/* The object is a file */
+					res = FR_NO_PATH;
+			}
+			if (res == FR_OK) {
+				dp->id = fs->id;
+				res = dir_sdi(dp, 0);			/* Rewind directory */
+#if _FS_LOCK
+				if (res == FR_OK) {
+					if (dp->sclust) {
+						dp->lockid = inc_lock(dp, 0);	/* Lock the sub directory */
+						if (!dp->lockid)
+							res = FR_TOO_MANY_OPEN_FILES;
+					} else {
+						dp->lockid = 0;	/* Root directory need not to be locked */
+					}
+				}
+#endif
+			}
+		}
+		if (res == FR_NO_FILE) res = FR_NO_PATH;
+	}
+	if (res != FR_OK) dp->fs = 0;		/* Invalidate the directory object if function faild */
+
+	LEAVE_FF(fs, res);
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Close Directory                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_closedir (
+	FATFS_DIR *dp		/* Pointer to the directory object to be closed */
+)
+{
+	FRESULT res;
+
+
+	res = validate(dp);
+	if (res == FR_OK) {
+#if _FS_REENTRANT
+		FATFS *fs = dp->fs;
+#endif
+#if _FS_LOCK
+		if (dp->lockid)				/* Decrement sub-directory open counter */
+			res = dec_lock(dp->lockid);
+		if (res == FR_OK)
+#endif
+			dp->fs = 0;				/* Invalidate directory object */
+#if _FS_REENTRANT
+		unlock_fs(fs, FR_OK);		/* Unlock volume */
+#endif
+	}
+	return res;
 }
 
 
 
 
 /*-----------------------------------------------------------------------*/
-/* Read Directory Entry in Sequence                                      */
+/* Read Directory Entries in Sequence                                    */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_readdir (
-    FATFS_DIR *dj,            /* Pointer to the open directory object */
-    FILINFO *fno        /* Pointer to file information to return */
+	FATFS_DIR* dp,			/* Pointer to the open directory object */
+	FILINFO* fno		/* Pointer to file information to return */
 )
 {
-    FRESULT res;
-    DEF_NAMEBUF;
-
-
-    res = validate(dj);                     /* Check validity of the object */
-    if (res == FR_OK) {
-        if (!fno) {
-            res = dir_sdi(dj, 0);           /* Rewind the directory object */
-        } else {
-            INIT_BUF(*dj);
-            res = dir_read(dj);             /* Read an directory item */
-            if (res == FR_NO_FILE) {        /* Reached end of dir */
-                dj->sect = 0;
-                res = FR_OK;
-            }
-            if (res == FR_OK) {             /* A valid entry is found */
-                get_fileinfo(dj, fno);      /* Get the object information */
-                res = dir_next(dj, 0);      /* Increment index for next */
-                if (res == FR_NO_FILE) {
-                    dj->sect = 0;
-                    res = FR_OK;
-                }
-            }
-            FREE_BUF();
-        }
-    }
-
-    LEAVE_FF(dj->fs, res);
+	FRESULT res;
+	DEFINE_NAMEBUF;
+
+
+	res = validate(dp);						/* Check validity of the object */
+	if (res == FR_OK) {
+		if (!fno) {
+			res = dir_sdi(dp, 0);			/* Rewind the directory object */
+		} else {
+			INIT_BUF(*dp);
+			res = dir_read(dp, 0);			/* Read an item */
+			if (res == FR_NO_FILE) {		/* Reached end of directory */
+				dp->sect = 0;
+				res = FR_OK;
+			}
+			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) {
+					dp->sect = 0;
+					res = FR_OK;
+				}
+			}
+			FREE_BUF();
+		}
+	}
+
+	LEAVE_FF(dp->fs, res);
 }
 
 
 
+#if _USE_FIND
+/*-----------------------------------------------------------------------*/
+/* Find next file                                                        */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_findnext (
+	FATFS_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 _USE_LFN
+		if (fno->lfname && pattern_matching(dp->pat, fno->lfname, 0, 0)) break;	/* Test for LFN if exist */
+#endif
+		if (pattern_matching(dp->pat, fno->fname, 0, 0)) break;	/* Test for SFN */
+	}
+	return res;
+
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Find first file                                                       */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_findfirst (
+	FATFS_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 */
+	const TCHAR* path,	/* Pointer to the file path */
+	FILINFO* fno		/* Pointer to file information to return */
 )
 {
-    FRESULT res;
-    FATFS_DIR dj;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 0);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);   /* Follow the file path */
-        if (res == FR_OK) {             /* Follow completed */
-            if (dj.dir)     /* Found an object */
-                get_fileinfo(&dj, fno);
-            else            /* It is root dir */
-                res = FR_INVALID_NAME;
-        }
-        FREE_BUF();
-    }
-
-    LEAVE_FF(dj.fs, res);
+	FRESULT res;
+	FATFS_DIR dj;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 0);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		if (res == FR_OK) {				/* Follow completed */
+			if (dj.FATFS_DIR) {		/* Found an object */
+				if (fno) get_fileinfo(&dj, fno);
+			} else {			/* It is root directory */
+				res = FR_INVALID_NAME;
+			}
+		}
+		FREE_BUF();
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
@@ -3145,63 +3372,63 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_getfree (
-    const TCHAR *path,  /* Pointer to the logical drive number (root dir) */
-    DWORD *nclst,       /* Pointer to the variable to return number of free clusters */
-    FATFS **fatfs       /* Pointer to pointer to corresponding file system object to return */
+	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 n, clst, sect, stat;
-    UINT i;
-    BYTE fat, *p;
-
-
-    /* Get drive number */
-    res = chk_mounted(&path, fatfs, 0);
-    fs = *fatfs;
-    if (res == FR_OK) {
-        /* If free_clust is valid, return it without full cluster scan */
-        if (fs->free_clust <= fs->n_fatent - 2) {
-            *nclst = fs->free_clust;
-        } else {
-            /* Get number of free clusters */
-            fat = fs->fs_type;
-            n = 0;
-            if (fat == FS_FAT12) {
-                clst = 2;
-                do {
-                    stat = get_fat(fs, clst);
-                    if (stat == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
-                    if (stat == 1) { res = FR_INT_ERR; break; }
-                    if (stat == 0) n++;
-                } while (++clst < fs->n_fatent);
-            } else {
-                clst = fs->n_fatent;
-                sect = fs->fatbase;
-                i = 0; p = 0;
-                do {
-                    if (!i) {
-                        res = move_window(fs, sect++);
-                        if (res != FR_OK) break;
-                        p = fs->win;
-                        i = SS(fs);
-                    }
-                    if (fat == FS_FAT16) {
-                        if (LD_WORD(p) == 0) n++;
-                        p += 2; i -= 2;
-                    } else {
-                        if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;
-                        p += 4; i -= 4;
-                    }
-                } while (--clst);
-            }
-            fs->free_clust = n;
-            if (fat == FS_FAT32) fs->fsi_flag = 1;
-            *nclst = n;
-        }
-    }
-    LEAVE_FF(fs, res);
+	FRESULT res;
+	FATFS *fs;
+	DWORD n, clst, sect, stat;
+	UINT i;
+	BYTE fat, *p;
+
+
+	/* Get logical drive number */
+	res = find_volume(fatfs, &path, 0);
+	fs = *fatfs;
+	if (res == FR_OK) {
+		/* If free_clust is valid, return it without full cluster scan */
+		if (fs->free_clust <= fs->n_fatent - 2) {
+			*nclst = fs->free_clust;
+		} else {
+			/* Get number of free clusters */
+			fat = fs->fs_type;
+			n = 0;
+			if (fat == FS_FAT12) {
+				clst = 2;
+				do {
+					stat = get_fat(fs, clst);
+					if (stat == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
+					if (stat == 1) { res = FR_INT_ERR; break; }
+					if (stat == 0) n++;
+				} while (++clst < fs->n_fatent);
+			} else {
+				clst = fs->n_fatent;
+				sect = fs->fatbase;
+				i = 0; p = 0;
+				do {
+					if (!i) {
+						res = move_window(fs, sect++);
+						if (res != FR_OK) break;
+						p = fs->win;
+						i = SS(fs);
+					}
+					if (fat == FS_FAT16) {
+						if (LD_WORD(p) == 0) n++;
+						p += 2; i -= 2;
+					} else {
+						if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;
+						p += 4; i -= 4;
+					}
+				} while (--clst);
+			}
+			fs->free_clust = n;
+			fs->fsi_flag |= 1;
+			*nclst = n;
+		}
+	}
+	LEAVE_FF(fs, res);
 }
 
 
@@ -3212,46 +3439,52 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_truncate (
-    FIL *fp     /* Pointer to the file object */
+	FIL* fp		/* Pointer to the file object */
 )
 {
-    FRESULT res;
-    DWORD ncl;
-
-
-    if (!fp) return FR_INVALID_OBJECT;
-
-    res = validate(fp);                     /* Check validity of the object */
-    if (res == FR_OK) {
-        if (fp->flag & FA__ERROR) {         /* Check abort flag */
-            res = FR_INT_ERR;
-        } else {
-            if (!(fp->flag & FA_WRITE))     /* Check access mode */
-                res = FR_DENIED;
-        }
-    }
-    if (res == FR_OK) {
-        if (fp->fsize > fp->fptr) {
-            fp->fsize = fp->fptr;   /* Set file size to current R/W point */
-            fp->flag |= FA__WRITTEN;
-            if (fp->fptr == 0) {    /* When set file size to zero, remove entire cluster chain */
-                res = remove_chain(fp->fs, fp->sclust);
-                fp->sclust = 0;
-            } else {                /* When truncate a part of the file, remove remaining clusters */
-                ncl = get_fat(fp->fs, fp->clust);
-                res = FR_OK;
-                if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
-                if (ncl == 1) res = FR_INT_ERR;
-                if (res == FR_OK && ncl < fp->fs->n_fatent) {
-                    res = put_fat(fp->fs, fp->clust, 0x0FFFFFFF);
-                    if (res == FR_OK) res = remove_chain(fp->fs, ncl);
-                }
-            }
-        }
-        if (res != FR_OK) fp->flag |= FA__ERROR;
-    }
-
-    LEAVE_FF(fp->fs, res);
+	FRESULT res;
+	DWORD ncl;
+
+
+	res = validate(fp);						/* Check validity of the object */
+	if (res == FR_OK) {
+		if (fp->err) {						/* Check error */
+			res = (FRESULT)fp->err;
+		} else {
+			if (!(fp->flag & FA_WRITE))		/* Check access mode */
+				res = FR_DENIED;
+		}
+	}
+	if (res == FR_OK) {
+		if (fp->fsize > fp->fptr) {
+			fp->fsize = fp->fptr;	/* Set file size to current R/W point */
+			fp->flag |= FA__WRITTEN;
+			if (fp->fptr == 0) {	/* When set file size to zero, remove entire cluster chain */
+				res = remove_chain(fp->fs, fp->sclust);
+				fp->sclust = 0;
+			} else {				/* When truncate a part of the file, remove remaining clusters */
+				ncl = get_fat(fp->fs, fp->clust);
+				res = FR_OK;
+				if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
+				if (ncl == 1) res = FR_INT_ERR;
+				if (res == FR_OK && ncl < fp->fs->n_fatent) {
+					res = put_fat(fp->fs, fp->clust, 0x0FFFFFFF);
+					if (res == FR_OK) res = remove_chain(fp->fs, ncl);
+				}
+			}
+#if !_FS_TINY
+			if (res == FR_OK && (fp->flag & FA__DIRTY)) {
+				if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
+					res = FR_DISK_ERR;
+				else
+					fp->flag &= ~FA__DIRTY;
+			}
+#endif
+		}
+		if (res != FR_OK) fp->err = (FRESULT)res;
+	}
+
+	LEAVE_FF(fp->fs, res);
 }
 
 
@@ -3262,64 +3495,65 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_unlink (
-    const TCHAR *path       /* Pointer to the file or directory path */
+	const TCHAR* path		/* Pointer to the file or directory path */
 )
 {
-    FRESULT res;
-    FATFS_DIR dj, sdj;
-    BYTE *dir;
-    DWORD dclst;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 1);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);       /* Follow the file path */
-        if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
-            res = FR_INVALID_NAME;          /* Cannot remove dot entry */
+	FRESULT res;
+	FATFS_DIR dj, sdj;
+	BYTE *FATFS_DIR;
+	DWORD dclst = 0;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 1);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		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
-        if (res == FR_OK) res = chk_lock(&dj, 2);   /* Cannot remove open file */
+		if (res == FR_OK) res = chk_lock(&dj, 2);	/* Cannot remove open object */
 #endif
-        if (res == FR_OK) {                 /* The object is accessible */
-            dir = dj.dir;
-            if (!dir) {
-                res = FR_INVALID_NAME;      /* Cannot remove the start directory */
-            } else {
-                if (dir[DIR_Attr] & AM_RDO)
-                    res = FR_DENIED;        /* Cannot remove R/O object */
-            }
-            dclst = ld_clust(dj.fs, dir);
-            if (res == FR_OK && (dir[DIR_Attr] & AM_DIR)) { /* Is it a sub-dir? */
-                if (dclst < 2) {
-                    res = FR_INT_ERR;
-                } else {
-                    mem_cpy(&sdj, &dj, sizeof (FATFS_DIR));   /* Check if the sub-dir is empty or not */
-                    sdj.sclust = dclst;
-                    res = dir_sdi(&sdj, 2);     /* Exclude dot entries */
-                    if (res == FR_OK) {
-                        res = dir_read(&sdj);
-                        if (res == FR_OK        /* Not empty dir */
+		if (res == FR_OK) {					/* The object is accessible */
+			FATFS_DIR = dj.FATFS_DIR;
+			if (!FATFS_DIR) {
+				res = FR_INVALID_NAME;		/* Cannot remove the origin directory */
+			} else {
+				if (FATFS_DIR[DIR_Attr] & AM_RDO)
+					res = FR_DENIED;		/* Cannot remove R/O object */
+			}
+			if (res == FR_OK) {
+				dclst = ld_clust(dj.fs, FATFS_DIR);
+				if (dclst && (FATFS_DIR[DIR_Attr] & AM_DIR)) {	/* Is it a sub-directory ? */
 #if _FS_RPATH
-                        || dclst == dj.fs->cdir /* Current dir */
+					if (dclst == dj.fs->cdir) {		 		/* Is it the current directory? */
+						res = FR_DENIED;
+					} else
 #endif
-                        ) res = FR_DENIED;
-                        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) {
-                    if (dclst)              /* Remove the cluster chain if exist */
-                        res = remove_chain(dj.fs, dclst);
-                    if (res == FR_OK) res = sync(dj.fs);
-                }
-            }
-        }
-        FREE_BUF();
-    }
-    LEAVE_FF(dj.fs, res);
+					{
+						mem_cpy(&sdj, &dj, sizeof (FATFS_DIR));	/* Open the sub-directory */
+						sdj.sclust = dclst;
+						res = dir_sdi(&sdj, 2);
+						if (res == FR_OK) {
+							res = dir_read(&sdj, 0);			/* Read an item (excluding dot entries) */
+							if (res == FR_OK) res = FR_DENIED;	/* Not empty? (cannot remove) */
+							if (res == FR_NO_FILE) res = FR_OK;	/* Empty? (can remove) */
+						}
+					}
+				}
+			}
+			if (res == FR_OK) {
+				res = dir_remove(&dj);		/* Remove the directory entry */
+				if (res == FR_OK && dclst)	/* Remove the cluster chain if exist */
+					res = remove_chain(dj.fs, dclst);
+				if (res == FR_OK) res = sync_fs(dj.fs);
+			}
+		}
+		FREE_BUF();
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
@@ -3330,69 +3564,70 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_mkdir (
-    const TCHAR *path       /* Pointer to the directory path */
+	const TCHAR* path		/* Pointer to the directory path */
 )
 {
-    FRESULT res;
-    FATFS_DIR dj;
-    BYTE *dir, n;
-    DWORD dsc, dcl, pcl, tim = get_fattime();
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 1);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        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[NS] & NS_DOT))
-            res = FR_INVALID_NAME;
-        if (res == FR_NO_FILE) {                /* Can create a new directory */
-            dcl = create_chain(dj.fs, 0);       /* Allocate a cluster for the new directory table */
-            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)                   /* Flush FAT */
-                res = move_window(dj.fs, 0);
-            if (res == FR_OK) {                 /* Initialize the new directory table */
-                dsc = clust2sect(dj.fs, dcl);
-                dir = dj.fs->win;
-                mem_set(dir, 0, SS(dj.fs));
-                mem_set(dir+DIR_Name, ' ', 8+3);    /* Create "." entry */
-                dir[DIR_Name] = '.';
-                dir[DIR_Attr] = AM_DIR;
-                ST_DWORD(dir+DIR_WrtTime, tim);
-                st_clust(dir, dcl);
-                mem_cpy(dir+SZ_DIR, dir, SZ_DIR);   /* Create ".." entry */
-                dir[33] = '.'; pcl = dj.sclust;
-                if (dj.fs->fs_type == FS_FAT32 && pcl == dj.fs->dirbase)
-                    pcl = 0;
-                st_clust(dir+SZ_DIR, pcl);
-                for (n = dj.fs->csize; n; n--) {    /* Write dot entries and clear following sectors */
-                    dj.fs->winsect = dsc++;
-                    dj.fs->wflag = 1;
-                    res = move_window(dj.fs, 0);
-                    if (res != FR_OK) break;
-                    mem_set(dir, 0, SS(dj.fs));
-                }
-            }
-            if (res == FR_OK) res = dir_register(&dj);  /* Register the object to the directoy */
-            if (res != FR_OK) {
-                remove_chain(dj.fs, dcl);           /* Could not register, remove cluster chain */
-            } else {
-                dir = dj.dir;
-                dir[DIR_Attr] = AM_DIR;             /* Attribute */
-                ST_DWORD(dir+DIR_WrtTime, tim);     /* Created time */
-                st_clust(dir, dcl);                 /* Table start cluster */
-                dj.fs->wflag = 1;
-                res = sync(dj.fs);
-            }
-        }
-        FREE_BUF();
-    }
-
-    LEAVE_FF(dj.fs, res);
+	FRESULT res;
+	FATFS_DIR dj;
+	BYTE *FATFS_DIR, n;
+	DWORD dsc, dcl, pcl, tm = GET_FATTIME();
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 1);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		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.fs, 0);		/* Allocate a cluster for the new directory table */
+			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)					/* Flush FAT */
+				res = sync_window(dj.fs);
+			if (res == FR_OK) {					/* Initialize the new directory table */
+				dsc = clust2sect(dj.fs, dcl);
+				FATFS_DIR = dj.fs->win;
+				mem_set(FATFS_DIR, 0, SS(dj.fs));
+				mem_set(FATFS_DIR + DIR_Name, ' ', 11);	/* Create "." entry */
+				FATFS_DIR[DIR_Name] = '.';
+				FATFS_DIR[DIR_Attr] = AM_DIR;
+				ST_DWORD(FATFS_DIR + DIR_WrtTime, tm);
+				st_clust(FATFS_DIR, dcl);
+				mem_cpy(FATFS_DIR + SZ_DIRE, FATFS_DIR, SZ_DIRE); 	/* Create ".." entry */
+				FATFS_DIR[SZ_DIRE + 1] = '.'; pcl = dj.sclust;
+				if (dj.fs->fs_type == FS_FAT32 && pcl == dj.fs->dirbase)
+					pcl = 0;
+				st_clust(FATFS_DIR + SZ_DIRE, pcl);
+				for (n = dj.fs->csize; n; n--) {	/* Write dot entries and clear following sectors */
+					dj.fs->winsect = dsc++;
+					dj.fs->wflag = 1;
+					res = sync_window(dj.fs);
+					if (res != FR_OK) break;
+					mem_set(FATFS_DIR, 0, SS(dj.fs));
+				}
+			}
+			if (res == FR_OK) res = dir_register(&dj);	/* Register the object to the directoy */
+			if (res != FR_OK) {
+				remove_chain(dj.fs, dcl);			/* Could not register, remove cluster chain */
+			} else {
+				FATFS_DIR = dj.FATFS_DIR;
+				FATFS_DIR[DIR_Attr] = AM_DIR;				/* Attribute */
+				ST_DWORD(FATFS_DIR + DIR_WrtTime, tm);	/* Created time */
+				st_clust(FATFS_DIR, dcl);					/* Table start cluster */
+				dj.fs->wflag = 1;
+				res = sync_fs(dj.fs);
+			}
+		}
+		FREE_BUF();
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
@@ -3403,79 +3638,39 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_chmod (
-    const TCHAR *path,  /* Pointer to the file path */
-    BYTE value,         /* Attribute bits */
-    BYTE mask           /* Attribute mask to change */
+	const TCHAR* path,	/* Pointer to the file path */
+	BYTE attr,			/* Attribute bits */
+	BYTE mask			/* Attribute mask to change */
 )
 {
-    FRESULT res;
-    FATFS_DIR dj;
-    BYTE *dir;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 1);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);       /* Follow the file path */
-        FREE_BUF();
-        if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
-            res = FR_INVALID_NAME;
-        if (res == FR_OK) {
-            dir = dj.dir;
-            if (!dir) {                     /* Is it a root directory? */
-                res = FR_INVALID_NAME;
-            } else {                        /* File or sub directory */
-                mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;    /* Valid attribute mask */
-                dir[DIR_Attr] = (value & mask) | (dir[DIR_Attr] & (BYTE)~mask); /* Apply attribute change */
-                dj.fs->wflag = 1;
-                res = sync(dj.fs);
-            }
-        }
-    }
-
-    LEAVE_FF(dj.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;
-    FATFS_DIR dj;
-    BYTE *dir;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path, &dj.fs, 1);
-    if (res == FR_OK) {
-        INIT_BUF(dj);
-        res = follow_path(&dj, path);   /* Follow the file path */
-        FREE_BUF();
-        if (_FS_RPATH && res == FR_OK && (dj.fn[NS] & NS_DOT))
-            res = FR_INVALID_NAME;
-        if (res == FR_OK) {
-            dir = dj.dir;
-            if (!dir) {                 /* Root directory */
-                res = FR_INVALID_NAME;
-            } else {                    /* File or sub-directory */
-                ST_WORD(dir+DIR_WrtTime, fno->ftime);
-                ST_WORD(dir+DIR_WrtDate, fno->fdate);
-                dj.fs->wflag = 1;
-                res = sync(dj.fs);
-            }
-        }
-    }
-
-    LEAVE_FF(dj.fs, res);
+	FRESULT res;
+	FATFS_DIR dj;
+	BYTE *FATFS_DIR;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 1);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		res = follow_path(&dj, path);		/* Follow the file path */
+		FREE_BUF();
+		if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT))
+			res = FR_INVALID_NAME;
+		if (res == FR_OK) {
+			FATFS_DIR = dj.FATFS_DIR;
+			if (!FATFS_DIR) {						/* Is it a root directory? */
+				res = FR_INVALID_NAME;
+			} else {						/* File or sub directory */
+				mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;	/* Valid attribute mask */
+				FATFS_DIR[DIR_Attr] = (attr & mask) | (FATFS_DIR[DIR_Attr] & (BYTE)~mask);	/* Apply attribute change */
+				dj.fs->wflag = 1;
+				res = sync_fs(dj.fs);
+			}
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 
@@ -3486,70 +3681,116 @@
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_rename (
-    const TCHAR *path_old,  /* Pointer to the old name */
-    const TCHAR *path_new   /* Pointer to the new name */
+	const TCHAR* path_old,	/* Pointer to the object to be renamed */
+	const TCHAR* path_new	/* Pointer to the new name */
 )
 {
-    FRESULT res;
-    FATFS_DIR djo, djn;
-    BYTE buf[21], *dir;
-    DWORD dw;
-    DEF_NAMEBUF;
-
-
-    res = chk_mounted(&path_old, &djo.fs, 1);
-    if (res == FR_OK) {
-        djn.fs = djo.fs;
-        INIT_BUF(djo);
-        res = follow_path(&djo, path_old);      /* Check old object */
-        if (_FS_RPATH && res == FR_OK && (djo.fn[NS] & NS_DOT))
-            res = FR_INVALID_NAME;
+	FRESULT res;
+	FATFS_DIR djo, djn;
+	BYTE buf[21], *FATFS_DIR;
+	DWORD dw;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number of the source object */
+	res = find_volume(&djo.fs, &path_old, 1);
+	if (res == FR_OK) {
+		djn.fs = djo.fs;
+		INIT_BUF(djo);
+		res = follow_path(&djo, path_old);		/* Check old object */
+		if (_FS_RPATH && res == FR_OK && (djo.fn[NSFLAG] & NS_DOT))
+			res = FR_INVALID_NAME;
 #if _FS_LOCK
-        if (res == FR_OK) res = chk_lock(&djo, 2);
+		if (res == FR_OK) res = chk_lock(&djo, 2);
 #endif
-        if (res == FR_OK) {                     /* Old object is found */
-            if (!djo.dir) {                     /* Is root dir? */
-                res = FR_NO_FILE;
-            } else {
-                mem_cpy(buf, djo.dir+DIR_Attr, 21);     /* Save the object information except for name */
-                mem_cpy(&djn, &djo, sizeof (FATFS_DIR));      /* Check new object */
-                res = follow_path(&djn, path_new);
-                if (res == FR_OK) res = FR_EXIST;       /* The new object name is already existing */
-                if (res == FR_NO_FILE) {                /* Is it a valid path and no name collision? */
-/* Start critical section that an interruption or error can cause cross-link */
-                    res = dir_register(&djn);           /* Register the new entry */
-                    if (res == FR_OK) {
-                        dir = djn.dir;                  /* Copy object information except for name */
-                        mem_cpy(dir+13, buf+2, 19);
-                        dir[DIR_Attr] = buf[0] | AM_ARC;
-                        djo.fs->wflag = 1;
-                        if (djo.sclust != djn.sclust && (dir[DIR_Attr] & AM_DIR)) {     /* Update .. entry in the directory if needed */
-                            dw = clust2sect(djo.fs, ld_clust(djo.fs, dir));
-                            if (!dw) {
-                                res = FR_INT_ERR;
-                            } else {
-                                res = move_window(djo.fs, dw);
-                                dir = djo.fs->win+SZ_DIR;   /* .. entry */
-                                if (res == FR_OK && dir[1] == '.') {
-                                    dw = (djo.fs->fs_type == FS_FAT32 && djn.sclust == djo.fs->dirbase) ? 0 : djn.sclust;
-                                    st_clust(dir, dw);
-                                    djo.fs->wflag = 1;
-                                }
-                            }
-                        }
-                        if (res == FR_OK) {
-                            res = dir_remove(&djo);     /* Remove old entry */
-                            if (res == FR_OK)
-                                res = sync(djo.fs);
-                        }
-                    }
-/* End critical section */
-                }
-            }
-        }
-        FREE_BUF();
-    }
-    LEAVE_FF(djo.fs, res);
+		if (res == FR_OK) {						/* Old object is found */
+			if (!djo.FATFS_DIR) {						/* Is root FATFS_DIR? */
+				res = FR_NO_FILE;
+			} else {
+				mem_cpy(buf, djo.FATFS_DIR + DIR_Attr, 21);	/* Save information about object except name */
+				mem_cpy(&djn, &djo, sizeof (FATFS_DIR));		/* Duplicate the directory object */
+				if (get_ldnumber(&path_new) >= 0)		/* Snip drive number off and ignore it */
+					res = follow_path(&djn, path_new);	/* and make sure if new object name is not conflicting */
+				else
+					res = FR_INVALID_DRIVE;
+				if (res == FR_OK) res = FR_EXIST;		/* The new object name is already existing */
+				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) {
+/* Start of critical section where any interruption can cause a cross-link */
+						FATFS_DIR = djn.FATFS_DIR;					/* Copy information about object except name */
+						mem_cpy(FATFS_DIR + 13, buf + 2, 19);
+						FATFS_DIR[DIR_Attr] = buf[0] | AM_ARC;
+						djo.fs->wflag = 1;
+						if ((FATFS_DIR[DIR_Attr] & AM_DIR) && djo.sclust != djn.sclust) {	/* Update .. entry in the sub-directory if needed */
+							dw = clust2sect(djo.fs, ld_clust(djo.fs, FATFS_DIR));
+							if (!dw) {
+								res = FR_INT_ERR;
+							} else {
+								res = move_window(djo.fs, dw);
+								FATFS_DIR = djo.fs->win + SZ_DIRE * 1;	/* Ptr to .. entry */
+								if (res == FR_OK && FATFS_DIR[1] == '.') {
+									st_clust(FATFS_DIR, djn.sclust);
+									djo.fs->wflag = 1;
+								}
+							}
+						}
+						if (res == FR_OK) {
+							res = dir_remove(&djo);		/* Remove old entry */
+							if (res == FR_OK)
+								res = sync_fs(djo.fs);
+						}
+/* End of critical section */
+					}
+				}
+			}
+		}
+		FREE_BUF();
+	}
+
+	LEAVE_FF(djo.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;
+	FATFS_DIR dj;
+	BYTE *FATFS_DIR;
+	DEFINE_NAMEBUF;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 1);
+	if (res == FR_OK) {
+		INIT_BUF(dj);
+		res = follow_path(&dj, path);	/* Follow the file path */
+		FREE_BUF();
+		if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT))
+			res = FR_INVALID_NAME;
+		if (res == FR_OK) {
+			FATFS_DIR = dj.FATFS_DIR;
+			if (!FATFS_DIR) {					/* Root directory */
+				res = FR_INVALID_NAME;
+			} else {					/* File or sub-directory */
+				ST_WORD(FATFS_DIR + DIR_WrtTime, fno->ftime);
+				ST_WORD(FATFS_DIR + DIR_WrtDate, fno->fdate);
+				dj.fs->wflag = 1;
+				res = sync_fs(dj.fs);
+			}
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
 }
 
 #endif /* !_FS_READONLY */
@@ -3559,63 +3800,225 @@
 
 
 
+
+#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;
+	FATFS_DIR dj;
+	UINT i, j;
+#if _USE_LFN && _LFN_UNICODE
+	WCHAR w;
+#endif
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &path, 0);
+
+	/* Get volume label */
+	if (res == FR_OK && label) {
+		dj.sclust = 0;					/* Open root directory */
+		res = dir_sdi(&dj, 0);
+		if (res == FR_OK) {
+			res = dir_read(&dj, 1);		/* Get an entry with AM_VOL */
+			if (res == FR_OK) {			/* A volume label is exist */
+#if _USE_LFN && _LFN_UNICODE
+				i = j = 0;
+				do {
+					w = (i < 11) ? dj.FATFS_DIR[i++] : ' ';
+					if (IsDBCS1(w) && i < 11 && IsDBCS2(dj.FATFS_DIR[i]))
+						w = w << 8 | dj.FATFS_DIR[i++];
+					label[j++] = ff_convert(w, 1);	/* OEM -> Unicode */
+				} while (j < 11);
+#else
+				mem_cpy(label, dj.FATFS_DIR, 11);
+#endif
+				j = 11;
+				do {
+					label[j] = 0;
+					if (!j) break;
+				} while (label[--j] == ' ');
+			}
+			if (res == FR_NO_FILE) {	/* No label, return nul string */
+				label[0] = 0;
+				res = FR_OK;
+			}
+		}
+	}
+
+	/* Get volume serial number */
+	if (res == FR_OK && vsn) {
+		res = move_window(dj.fs, dj.fs->volbase);
+		if (res == FR_OK) {
+			i = dj.fs->fs_type == FS_FAT32 ? BS_VolID32 : BS_VolID;
+			*vsn = LD_DWORD(&dj.fs->win[i]);
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+
+
+#if !_FS_READONLY
+/*-----------------------------------------------------------------------*/
+/* Set volume label                                                      */
+/*-----------------------------------------------------------------------*/
+
+FRESULT f_setlabel (
+	const TCHAR* label	/* Pointer to the volume label to set */
+)
+{
+	FRESULT res;
+	FATFS_DIR dj;
+	BYTE vn[11];
+	UINT i, j, sl;
+	WCHAR w;
+	DWORD tm;
+
+
+	/* Get logical drive number */
+	res = find_volume(&dj.fs, &label, 1);
+	if (res) LEAVE_FF(dj.fs, res);
+
+	/* Create a volume label in directory form */
+	vn[0] = 0;
+	for (sl = 0; label[sl]; sl++) ;				/* Get name length */
+	for ( ; sl && label[sl - 1] == ' '; sl--) ;	/* Remove trailing spaces */
+	if (sl) {	/* Create volume label in directory form */
+		i = j = 0;
+		do {
+#if _USE_LFN && _LFN_UNICODE
+			w = ff_convert(ff_wtoupper(label[i++]), 0);
+#else
+			w = (BYTE)label[i++];
+			if (IsDBCS1(w))
+				w = (j < 10 && i < sl && IsDBCS2(label[i])) ? w << 8 | (BYTE)label[i++] : 0;
+#if _USE_LFN
+			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 || chk_chr("\"*+,.:;<=>\?[]|\x7F", w) || j >= (UINT)((w >= 0x100) ? 10 : 11)) /* Reject invalid characters for volume label */
+				LEAVE_FF(dj.fs, FR_INVALID_NAME);
+			if (w >= 0x100) vn[j++] = (BYTE)(w >> 8);
+			vn[j++] = (BYTE)w;
+		} while (i < sl);
+		while (j < 11) vn[j++] = ' ';	/* Fill remaining name field */
+		if (vn[0] == DDEM) LEAVE_FF(dj.fs, FR_INVALID_NAME);	/* Reject illegal name (heading DDEM) */
+	}
+
+	/* Set volume label */
+	dj.sclust = 0;					/* Open root directory */
+	res = dir_sdi(&dj, 0);
+	if (res == FR_OK) {
+		res = dir_read(&dj, 1);		/* Get an entry with AM_VOL */
+		if (res == FR_OK) {			/* A volume label is found */
+			if (vn[0]) {
+				mem_cpy(dj.FATFS_DIR, vn, 11);	/* Change the volume label name */
+				tm = GET_FATTIME();
+				ST_DWORD(dj.FATFS_DIR + DIR_WrtTime, tm);
+			} else {
+				dj.FATFS_DIR[0] = DDEM;			/* Remove the volume label */
+			}
+			dj.fs->wflag = 1;
+			res = sync_fs(dj.fs);
+		} else {					/* No volume label is found or error */
+			if (res == FR_NO_FILE) {
+				res = FR_OK;
+				if (vn[0]) {				/* Create volume label as new */
+					res = dir_alloc(&dj, 1);	/* Allocate an entry for volume label */
+					if (res == FR_OK) {
+						mem_set(dj.FATFS_DIR, 0, SZ_DIRE);	/* Set volume label */
+						mem_cpy(dj.FATFS_DIR, vn, 11);
+						dj.FATFS_DIR[DIR_Attr] = AM_VOL;
+						tm = GET_FATTIME();
+						ST_DWORD(dj.FATFS_DIR + DIR_WrtTime, tm);
+						dj.fs->wflag = 1;
+						res = sync_fs(dj.fs);
+					}
+				}
+			}
+		}
+	}
+
+	LEAVE_FF(dj.fs, res);
+}
+
+#endif /* !_FS_READONLY */
+#endif /* _USE_LABEL */
+
+
+
 /*-----------------------------------------------------------------------*/
 /* Forward data to the stream directly (available on only tiny cfg)      */
 /*-----------------------------------------------------------------------*/
 #if _USE_FORWARD && _FS_TINY
 
 FRESULT f_forward (
-    FIL *fp,                        /* Pointer to the file object */
-    UINT (*func)(const BYTE*,UINT), /* Pointer to the streaming function */
-    UINT btr,                       /* Number of bytes to forward */
-    UINT *bf                        /* Pointer to number of bytes forwarded */
+	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;
-    DWORD remain, clst, sect;
-    UINT rcnt;
-    BYTE csect;
-
-
-    *bf = 0;    /* Clear transfer byte counter */
-
-    if (!fp) return FR_INVALID_OBJECT;
-
-    res = validate(fp);                             /* Check validity of the object */
-    if (res != FR_OK) LEAVE_FF(fp->fs, res);
-    if (fp->flag & FA__ERROR)                       /* Check error flag */
-        LEAVE_FF(fp->fs, FR_INT_ERR);
-    if (!(fp->flag & FA_READ))                      /* Check access mode */
-        LEAVE_FF(fp->fs, FR_DENIED);
-
-    remain = fp->fsize - fp->fptr;
-    if (btr > remain) btr = (UINT)remain;           /* Truncate btr by remaining bytes */
-
-    for ( ;  btr && (*func)(0, 0);                  /* Repeat until all data transferred or stream becomes busy */
-        fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) {
-        csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
-        if ((fp->fptr % SS(fp->fs)) == 0) {         /* On the sector boundary? */
-            if (!csect) {                           /* On the cluster boundary? */
-                clst = (fp->fptr == 0) ?            /* On the top of the file? */
-                    fp->sclust : get_fat(fp->fs, fp->clust);
-                if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
-                if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
-                fp->clust = clst;                   /* Update current cluster */
-            }
-        }
-        sect = clust2sect(fp->fs, fp->clust);       /* Get current data sector */
-        if (!sect) ABORT(fp->fs, FR_INT_ERR);
-        sect += csect;
-        if (move_window(fp->fs, sect))              /* Move sector window */
-            ABORT(fp->fs, FR_DISK_ERR);
-        fp->dsect = sect;
-        rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs));  /* Forward data from sector window */
-        if (rcnt > btr) rcnt = btr;
-        rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);
-        if (!rcnt) ABORT(fp->fs, FR_INT_ERR);
-    }
-
-    LEAVE_FF(fp->fs, FR_OK);
+	FRESULT res;
+	DWORD remain, clst, sect;
+	UINT rcnt;
+	BYTE csect;
+
+
+	*bf = 0;	/* Clear transfer byte counter */
+
+	res = validate(fp);								/* Check validity of the object */
+	if (res != FR_OK) LEAVE_FF(fp->fs, res);
+	if (fp->err)									/* Check error */
+		LEAVE_FF(fp->fs, (FRESULT)fp->err);
+	if (!(fp->flag & FA_READ))						/* Check access mode */
+		LEAVE_FF(fp->fs, FR_DENIED);
+
+	remain = fp->fsize - 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 becomes busy */
+		fp->fptr += rcnt, *bf += rcnt, btf -= rcnt) {
+		csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));	/* Sector offset in the cluster */
+		if ((fp->fptr % SS(fp->fs)) == 0) {			/* On the sector boundary? */
+			if (!csect) {							/* On the cluster boundary? */
+				clst = (fp->fptr == 0) ?			/* On the top of the file? */
+					fp->sclust : get_fat(fp->fs, fp->clust);
+				if (clst <= 1) ABORT(fp->fs, FR_INT_ERR);
+				if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
+				fp->clust = clst;					/* Update current cluster */
+			}
+		}
+		sect = clust2sect(fp->fs, fp->clust);		/* Get current data sector */
+		if (!sect) ABORT(fp->fs, FR_INT_ERR);
+		sect += csect;
+		if (move_window(fp->fs, sect) != FR_OK)		/* Move sector window */
+			ABORT(fp->fs, FR_DISK_ERR);
+		fp->dsect = sect;
+		rcnt = SS(fp->fs) - (WORD)(fp->fptr % SS(fp->fs));	/* Forward data from sector window */
+		if (rcnt > btf) rcnt = btf;
+		rcnt = (*func)(&fp->fs->win[(WORD)fp->fptr % SS(fp->fs)], rcnt);
+		if (!rcnt) ABORT(fp->fs, FR_INT_ERR);
+	}
+
+	LEAVE_FF(fp->fs, FR_OK);
 }
 #endif /* _USE_FORWARD */
 
@@ -3623,311 +4026,321 @@
 
 #if _USE_MKFS && !_FS_READONLY
 /*-----------------------------------------------------------------------*/
-/* Create File System on the Drive                                       */
+/* Create file system on the logical drive                               */
 /*-----------------------------------------------------------------------*/
-#define N_ROOTDIR   512     /* Number of root dir entries for FAT12/16 */
-#define N_FATS      1       /* Number of FAT copies (1 or 2) */
+#define N_ROOTDIR	512		/* Number of root directory entries for FAT12/16 */
+#define N_FATS		1		/* Number of FATs (1 or 2) */
 
 
 FRESULT f_mkfs (
-    BYTE drv,       /* Logical drive number */
-    BYTE sfd,       /* Partitioning rule 0:FDISK, 1:SFD */
-    UINT au         /* Allocation unit size [bytes] */
+	const TCHAR* path,	/* Logical drive number */
+	BYTE sfd,			/* Partitioning rule 0:FDISK, 1:SFD */
+	UINT au				/* Size of allocation unit in unit of byte or sector */
 )
 {
-    static const WORD vst[] = { 1024,   512,  256,  128,   64,    32,   16,    8,    4,    2,   0};
-    static const WORD cst[] = {32768, 16384, 8192, 4096, 2048, 16384, 8192, 4096, 2048, 1024, 512};
-    BYTE fmt, md, sys, *tbl, pdrv, part;
-    DWORD n_clst, vs, n, wsect;
-    UINT i;
-    DWORD b_vol, b_fat, b_dir, b_data;  /* LBA */
-    DWORD n_vol, n_rsv, n_fat, n_dir;   /* Size */
-    FATFS *fs;
-    DSTATUS stat;
-
-
-    /* Check mounted drive and clear work area */
-    if (drv >= _VOLUMES) return FR_INVALID_DRIVE;
-    if (sfd > 1) return FR_INVALID_PARAMETER;
-    if (au & (au - 1)) return FR_INVALID_PARAMETER;
-    fs = FatFs[drv];
-    if (!fs) return FR_NOT_ENABLED;
-    fs->fs_type = 0;
-    pdrv = LD2PD(drv);  /* Physical drive */
-    part = LD2PT(drv);  /* Partition (0:auto detect, 1-4:get from partition table)*/
-
-    /* Get disk statics */
-    stat = disk_initialize(pdrv);
-    if (stat & STA_NOINIT) return FR_NOT_READY;
-    if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
-#if _MAX_SS != 512                  /* Get disk sector size */
-    if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS)
-        return FR_DISK_ERR;
+	static const WORD vst[] = { 1024,   512,  256,  128,   64,    32,   16,    8,    4,    2,   0};
+	static const WORD cst[] = {32768, 16384, 8192, 4096, 2048, 16384, 8192, 4096, 2048, 1024, 512};
+	int vol;
+	BYTE fmt, md, sys, *tbl, pdrv, part;
+	DWORD n_clst, vs, n, wsect;
+	UINT i;
+	DWORD b_vol, b_fat, b_dir, b_data;	/* LBA */
+	DWORD n_vol, n_rsv, n_fat, n_dir;	/* Size */
+	FATFS *fs;
+	DSTATUS stat;
+#if _USE_TRIM
+	DWORD eb[2];
+#endif
+
+
+	/* Check mounted drive and clear work area */
+	if (sfd > 1) return FR_INVALID_PARAMETER;
+	vol = get_ldnumber(&path);
+	if (vol < 0) return FR_INVALID_DRIVE;
+	fs = FatFs[vol];
+	if (!fs) return FR_NOT_ENABLED;
+	fs->fs_type = 0;
+	pdrv = LD2PD(vol);	/* Physical drive */
+	part = LD2PT(vol);	/* Partition (0:auto detect, 1-4:get from partition table)*/
+
+	/* Get disk statics */
+	stat = disk_initialize(pdrv);
+	if (stat & STA_NOINIT) return FR_NOT_READY;
+	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
+#if _MAX_SS != _MIN_SS		/* Get disk sector size */
+	if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS || SS(fs) < _MIN_SS)
+		return FR_DISK_ERR;
 #endif
-    if (_MULTI_PARTITION && part) {
-        /* Get partition information from partition table in the MBR */
-        if (disk_read(pdrv, fs->win, 0, 1) != RES_OK) return FR_DISK_ERR;
-        if (LD_WORD(fs->win+BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
-        tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
-        if (!tbl[4]) return FR_MKFS_ABORTED;    /* No partition? */
-        b_vol = LD_DWORD(tbl+8);    /* Volume start sector */
-        n_vol = LD_DWORD(tbl+12);   /* Volume size */
-    } else {
-        /* Create a partition in this function */
-        if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &n_vol) != RES_OK || n_vol < 128)
-            return FR_DISK_ERR;
-        b_vol = (sfd) ? 0 : 63;     /* Volume start sector */
-        n_vol -= b_vol;             /* Volume size */
-    }
-
-    if (!au) {              /* AU auto selection */
-        vs = n_vol / (2000 / (SS(fs) / 512));
-        for (i = 0; vs < vst[i]; i++) ;
-        au = cst[i];
-    }
-    au /= SS(fs);       /* Number of sectors per cluster */
-    if (au == 0) au = 1;
-    if (au > 128) au = 128;
-
-    /* Pre-compute number of clusters and FAT sub-type */
-    n_clst = n_vol / au;
-    fmt = FS_FAT12;
-    if (n_clst >= MIN_FAT16) fmt = FS_FAT16;
-    if (n_clst >= MIN_FAT32) fmt = FS_FAT32;
-
-    /* Determine offset and size of FAT structure */
-    if (fmt == FS_FAT32) {
-        n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);
-        n_rsv = 32;
-        n_dir = 0;
-    } else {
-        n_fat = (fmt == FS_FAT12) ? (n_clst * 3 + 1) / 2 + 3 : (n_clst * 2) + 4;
-        n_fat = (n_fat + SS(fs) - 1) / SS(fs);
-        n_rsv = 1;
-        n_dir = (DWORD)N_ROOTDIR * SZ_DIR / SS(fs);
-    }
-    b_fat = b_vol + n_rsv;              /* FAT area start sector */
-    b_dir = b_fat + n_fat * N_FATS;     /* Directory area start sector */
-    b_data = b_dir + n_dir;             /* Data area start sector */
-    if (n_vol < b_data + au - b_vol) return FR_MKFS_ABORTED;    /* Too small volume */
-
-    /* Align data start sector to erase block boundary (for flash memory media) */
-    if (disk_ioctl(pdrv, GET_BLOCK_SIZE, &n) != RES_OK || !n || n > 32768) n = 1;
-    n = (b_data + n - 1) & ~(n - 1);    /* Next nearest erase block from current data start */
-    n = (n - b_data) / N_FATS;
-    if (fmt == FS_FAT32) {      /* FAT32: Move FAT offset */
-        n_rsv += n;
-        b_fat += n;
-    } else {                    /* FAT12/16: Expand FAT size */
-        n_fat += n;
-    }
-
-    /* Determine number of clusters and final check of validity of the FAT sub-type */
-    n_clst = (n_vol - n_rsv - n_fat * N_FATS - n_dir) / au;
-    if (   (fmt == FS_FAT16 && n_clst < MIN_FAT16)
-        || (fmt == FS_FAT32 && n_clst < MIN_FAT32))
-        return FR_MKFS_ABORTED;
-
-    switch (fmt) {  /* Determine system ID for partition table */
-    case FS_FAT12:  sys = 0x01; break;
-    case FS_FAT16:  sys = (n_vol < 0x10000) ? 0x04 : 0x06; break;
-    default:        sys = 0x0C;
-    }
-
-    if (_MULTI_PARTITION && part) {
-        /* Update system ID in the partition table */
-        tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
-        tbl[4] = sys;
-        if (disk_write(pdrv, fs->win, 0, 1) != RES_OK) return FR_DISK_ERR;
-        md = 0xF8;
-    } else {
-        if (sfd) {  /* No partition table (SFD) */
-            md = 0xF0;
-        } else {    /* Create partition table (FDISK) */
-            mem_set(fs->win, 0, SS(fs));
-            tbl = fs->win+MBR_Table;    /* Create partition table for single partition in the drive */
-            tbl[1] = 1;                     /* Partition start head */
-            tbl[2] = 1;                     /* Partition start sector */
-            tbl[3] = 0;                     /* Partition start cylinder */
-            tbl[4] = sys;                   /* System type */
-            tbl[5] = 254;                   /* Partition end head */
-            n = (b_vol + n_vol) / 63 / 255;
-            tbl[6] = (BYTE)((n >> 2) | 63); /* Partition end sector */
-            tbl[7] = (BYTE)n;               /* End cylinder */
-            ST_DWORD(tbl+8, 63);            /* Partition start in LBA */
-            ST_DWORD(tbl+12, n_vol);        /* Partition size in LBA */
-            ST_WORD(fs->win+BS_55AA, 0xAA55);   /* MBR signature */
-            if (disk_write(pdrv, fs->win, 0, 1) != RES_OK)  /* Write it to the MBR sector */
-                return FR_DISK_ERR;
-            md = 0xF8;
-        }
-    }
-
-    /* Create BPB in the VBR */
-    tbl = fs->win;                          /* Clear sector */
-    mem_set(tbl, 0, SS(fs));
-    mem_cpy(tbl, "\xEB\xFE\x90" "MSDOS5.0", 11);/* Boot jump code, OEM name */
-    i = SS(fs);                             /* Sector size */
-    ST_WORD(tbl+BPB_BytsPerSec, i);
-    tbl[BPB_SecPerClus] = (BYTE)au;         /* Sectors per cluster */
-    ST_WORD(tbl+BPB_RsvdSecCnt, n_rsv);     /* Reserved sectors */
-    tbl[BPB_NumFATs] = N_FATS;              /* Number of FATs */
-    i = (fmt == FS_FAT32) ? 0 : N_ROOTDIR;  /* Number of rootdir entries */
-    ST_WORD(tbl+BPB_RootEntCnt, i);
-    if (n_vol < 0x10000) {                  /* Number of total sectors */
-        ST_WORD(tbl+BPB_TotSec16, n_vol);
-    } else {
-        ST_DWORD(tbl+BPB_TotSec32, n_vol);
-    }
-    tbl[BPB_Media] = md;                    /* Media descriptor */
-    ST_WORD(tbl+BPB_SecPerTrk, 63);         /* Number of sectors per track */
-    ST_WORD(tbl+BPB_NumHeads, 255);         /* Number of heads */
-    ST_DWORD(tbl+BPB_HiddSec, b_vol);       /* Hidden sectors */
-    n = get_fattime();                      /* Use current time as VSN */
-    if (fmt == FS_FAT32) {
-        ST_DWORD(tbl+BS_VolID32, n);        /* VSN */
-        ST_DWORD(tbl+BPB_FATSz32, n_fat);   /* Number of sectors per FAT */
-        ST_DWORD(tbl+BPB_RootClus, 2);      /* Root directory start cluster (2) */
-        ST_WORD(tbl+BPB_FSInfo, 1);         /* FSInfo record offset (VBR+1) */
-        ST_WORD(tbl+BPB_BkBootSec, 6);      /* Backup boot record offset (VBR+6) */
-        tbl[BS_DrvNum32] = 0x80;            /* Drive number */
-        tbl[BS_BootSig32] = 0x29;           /* Extended boot signature */
-        mem_cpy(tbl+BS_VolLab32, "NO NAME    " "FAT32   ", 19); /* Volume label, FAT signature */
-    } else {
-        ST_DWORD(tbl+BS_VolID, n);          /* VSN */
-        ST_WORD(tbl+BPB_FATSz16, n_fat);    /* Number of sectors per FAT */
-        tbl[BS_DrvNum] = 0x80;              /* Drive number */
-        tbl[BS_BootSig] = 0x29;             /* Extended boot signature */
-        mem_cpy(tbl+BS_VolLab, "NO NAME    " "FAT     ", 19);   /* Volume label, FAT signature */
-    }
-    ST_WORD(tbl+BS_55AA, 0xAA55);           /* Signature (Offset is fixed here regardless of sector size) */
-    if (disk_write(pdrv, tbl, b_vol, 1) != RES_OK)  /* Write it to the VBR sector */
-        return FR_DISK_ERR;
-    if (fmt == FS_FAT32)                            /* Write backup VBR if needed (VBR+6) */
-        disk_write(pdrv, tbl, b_vol + 6, 1);
-
-    /* Initialize FAT area */
-    wsect = b_fat;
-    for (i = 0; i < N_FATS; i++) {      /* Initialize each FAT copy */
-        mem_set(tbl, 0, SS(fs));            /* 1st sector of the FAT  */
-        n = md;                             /* Media descriptor byte */
-        if (fmt != FS_FAT32) {
-            n |= (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;
-            ST_DWORD(tbl+0, n);             /* Reserve cluster #0-1 (FAT12/16) */
-        } else {
-            n |= 0xFFFFFF00;
-            ST_DWORD(tbl+0, n);             /* Reserve cluster #0-1 (FAT32) */
-            ST_DWORD(tbl+4, 0xFFFFFFFF);
-            ST_DWORD(tbl+8, 0x0FFFFFFF);    /* Reserve cluster #2 for root dir */
-        }
-        if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
-            return FR_DISK_ERR;
-        mem_set(tbl, 0, SS(fs));            /* Fill following FAT entries with zero */
-        for (n = 1; n < n_fat; n++) {       /* This loop may take a time on FAT32 volume due to many single sector writes */
-            if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
-                return FR_DISK_ERR;
-        }
-    }
-
-    /* Initialize root directory */
-    i = (fmt == FS_FAT32) ? au : n_dir;
-    do {
-        if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
-            return FR_DISK_ERR;
-    } while (--i);
-
-#if _USE_ERASE  /* Erase data area if needed */
-    {
-        DWORD eb[2];
-
-        eb[0] = wsect; eb[1] = wsect + (n_clst - ((fmt == FS_FAT32) ? 1 : 0)) * au - 1;
-        disk_ioctl(pdrv, CTRL_ERASE_SECTOR, eb);
-    }
+	if (_MULTI_PARTITION && part) {
+		/* Get partition information from partition table in the MBR */
+		if (disk_read(pdrv, fs->win, 0, 1) != RES_OK) return FR_DISK_ERR;
+		if (LD_WORD(fs->win + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
+		tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
+		if (!tbl[4]) return FR_MKFS_ABORTED;	/* No partition? */
+		b_vol = LD_DWORD(tbl + 8);	/* Volume start sector */
+		n_vol = LD_DWORD(tbl + 12);	/* Volume size */
+	} else {
+		/* Create a partition in this function */
+		if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &n_vol) != RES_OK || n_vol < 128)
+			return FR_DISK_ERR;
+		b_vol = (sfd) ? 0 : 63;		/* Volume start sector */
+		n_vol -= b_vol;				/* Volume size */
+	}
+
+	if (au & (au - 1)) au = 0;
+	if (!au) {						/* AU auto selection */
+		vs = n_vol / (2000 / (SS(fs) / 512));
+		for (i = 0; vs < vst[i]; i++) ;
+		au = cst[i];
+	}
+	if (au >= _MIN_SS) au /= SS(fs);	/* Number of sectors per cluster */
+	if (!au) au = 1;
+	if (au > 128) au = 128;
+
+	/* Pre-compute number of clusters and FAT sub-type */
+	n_clst = n_vol / au;
+	fmt = FS_FAT12;
+	if (n_clst >= MIN_FAT16) fmt = FS_FAT16;
+	if (n_clst >= MIN_FAT32) fmt = FS_FAT32;
+
+	/* Determine offset and size of FAT structure */
+	if (fmt == FS_FAT32) {
+		n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);
+		n_rsv = 32;
+		n_dir = 0;
+	} else {
+		n_fat = (fmt == FS_FAT12) ? (n_clst * 3 + 1) / 2 + 3 : (n_clst * 2) + 4;
+		n_fat = (n_fat + SS(fs) - 1) / SS(fs);
+		n_rsv = 1;
+		n_dir = (DWORD)N_ROOTDIR * SZ_DIRE / SS(fs);
+	}
+	b_fat = b_vol + n_rsv;				/* FAT area start sector */
+	b_dir = b_fat + n_fat * N_FATS;		/* Directory area start sector */
+	b_data = b_dir + n_dir;				/* Data area start sector */
+	if (n_vol < b_data + au - b_vol) return FR_MKFS_ABORTED;	/* Too small volume */
+
+	/* Align data start sector to erase block boundary (for flash memory media) */
+	if (disk_ioctl(pdrv, GET_BLOCK_SIZE, &n) != RES_OK || !n || n > 32768) n = 1;
+	n = (b_data + n - 1) & ~(n - 1);	/* Next nearest erase block from current data start */
+	n = (n - b_data) / N_FATS;
+	if (fmt == FS_FAT32) {		/* FAT32: Move FAT offset */
+		n_rsv += n;
+		b_fat += n;
+	} else {					/* FAT12/16: Expand FAT size */
+		n_fat += n;
+	}
+
+	/* Determine number of clusters and final check of validity of the FAT sub-type */
+	n_clst = (n_vol - n_rsv - n_fat * N_FATS - n_dir) / au;
+	if (   (fmt == FS_FAT16 && n_clst < MIN_FAT16)
+		|| (fmt == FS_FAT32 && n_clst < MIN_FAT32))
+		return FR_MKFS_ABORTED;
+
+	/* Determine system ID in the partition table */
+	if (fmt == FS_FAT32) {
+		sys = 0x0C;		/* FAT32X */
+	} else {
+		if (fmt == FS_FAT12 && n_vol < 0x10000) {
+			sys = 0x01;	/* FAT12(<65536) */
+		} else {
+			sys = (n_vol < 0x10000) ? 0x04 : 0x06;	/* FAT16(<65536) : FAT12/16(>=65536) */
+		}
+	}
+
+	if (_MULTI_PARTITION && part) {
+		/* Update system ID in the partition table */
+		tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
+		tbl[4] = sys;
+		if (disk_write(pdrv, fs->win, 0, 1) != RES_OK)	/* Write it to teh MBR */
+			return FR_DISK_ERR;
+		md = 0xF8;
+	} else {
+		if (sfd) {	/* No partition table (SFD) */
+			md = 0xF0;
+		} else {	/* Create partition table (FDISK) */
+			mem_set(fs->win, 0, SS(fs));
+			tbl = fs->win + MBR_Table;	/* Create partition table for single partition in the drive */
+			tbl[1] = 1;						/* Partition start head */
+			tbl[2] = 1;						/* Partition start sector */
+			tbl[3] = 0;						/* Partition start cylinder */
+			tbl[4] = sys;					/* System type */
+			tbl[5] = 254;					/* Partition end head */
+			n = (b_vol + n_vol) / 63 / 255;
+			tbl[6] = (BYTE)(n >> 2 | 63);	/* Partition end sector */
+			tbl[7] = (BYTE)n;				/* End cylinder */
+			ST_DWORD(tbl + 8, 63);			/* Partition start in LBA */
+			ST_DWORD(tbl + 12, n_vol);		/* Partition size in LBA */
+			ST_WORD(fs->win + BS_55AA, 0xAA55);	/* MBR signature */
+			if (disk_write(pdrv, fs->win, 0, 1) != RES_OK)	/* Write it to the MBR */
+				return FR_DISK_ERR;
+			md = 0xF8;
+		}
+	}
+
+	/* Create BPB in the VBR */
+	tbl = fs->win;							/* Clear sector */
+	mem_set(tbl, 0, SS(fs));
+	mem_cpy(tbl, "\xEB\xFE\x90" "MSDOS5.0", 11);/* Boot jump code, OEM name */
+	i = SS(fs);								/* Sector size */
+	ST_WORD(tbl + BPB_BytsPerSec, i);
+	tbl[BPB_SecPerClus] = (BYTE)au;			/* Sectors per cluster */
+	ST_WORD(tbl + BPB_RsvdSecCnt, n_rsv);	/* Reserved sectors */
+	tbl[BPB_NumFATs] = N_FATS;				/* Number of FATs */
+	i = (fmt == FS_FAT32) ? 0 : N_ROOTDIR;	/* Number of root directory entries */
+	ST_WORD(tbl + BPB_RootEntCnt, i);
+	if (n_vol < 0x10000) {					/* Number of total sectors */
+		ST_WORD(tbl + BPB_TotSec16, n_vol);
+	} else {
+		ST_DWORD(tbl + BPB_TotSec32, n_vol);
+	}
+	tbl[BPB_Media] = md;					/* Media descriptor */
+	ST_WORD(tbl + BPB_SecPerTrk, 63);		/* Number of sectors per track */
+	ST_WORD(tbl + BPB_NumHeads, 255);		/* Number of heads */
+	ST_DWORD(tbl + BPB_HiddSec, b_vol);		/* Hidden sectors */
+	n = GET_FATTIME();						/* Use current time as VSN */
+	if (fmt == FS_FAT32) {
+		ST_DWORD(tbl + BS_VolID32, n);		/* VSN */
+		ST_DWORD(tbl + BPB_FATSz32, n_fat);	/* Number of sectors per FAT */
+		ST_DWORD(tbl + BPB_RootClus, 2);	/* Root directory start cluster (2) */
+		ST_WORD(tbl + BPB_FSInfo, 1);		/* FSINFO record offset (VBR + 1) */
+		ST_WORD(tbl + BPB_BkBootSec, 6);	/* Backup boot record offset (VBR + 6) */
+		tbl[BS_DrvNum32] = 0x80;			/* Drive number */
+		tbl[BS_BootSig32] = 0x29;			/* Extended boot signature */
+		mem_cpy(tbl + BS_VolLab32, "NO NAME    " "FAT32   ", 19);	/* Volume label, FAT signature */
+	} else {
+		ST_DWORD(tbl + BS_VolID, n);		/* VSN */
+		ST_WORD(tbl + BPB_FATSz16, n_fat);	/* Number of sectors per FAT */
+		tbl[BS_DrvNum] = 0x80;				/* Drive number */
+		tbl[BS_BootSig] = 0x29;				/* Extended boot signature */
+		mem_cpy(tbl + BS_VolLab, "NO NAME    " "FAT     ", 19);	/* Volume label, FAT signature */
+	}
+	ST_WORD(tbl + BS_55AA, 0xAA55);			/* Signature (Offset is fixed here regardless of sector size) */
+	if (disk_write(pdrv, tbl, b_vol, 1) != RES_OK)	/* Write it to the VBR sector */
+		return FR_DISK_ERR;
+	if (fmt == FS_FAT32)					/* Write backup VBR if needed (VBR + 6) */
+		disk_write(pdrv, tbl, b_vol + 6, 1);
+
+	/* Initialize FAT area */
+	wsect = b_fat;
+	for (i = 0; i < N_FATS; i++) {		/* Initialize each FAT copy */
+		mem_set(tbl, 0, SS(fs));			/* 1st sector of the FAT  */
+		n = md;								/* Media descriptor byte */
+		if (fmt != FS_FAT32) {
+			n |= (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;
+			ST_DWORD(tbl + 0, n);			/* Reserve cluster #0-1 (FAT12/16) */
+		} else {
+			n |= 0xFFFFFF00;
+			ST_DWORD(tbl + 0, n);			/* Reserve cluster #0-1 (FAT32) */
+			ST_DWORD(tbl + 4, 0xFFFFFFFF);
+			ST_DWORD(tbl + 8, 0x0FFFFFFF);	/* Reserve cluster #2 for root directory */
+		}
+		if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
+			return FR_DISK_ERR;
+		mem_set(tbl, 0, SS(fs));			/* Fill following FAT entries with zero */
+		for (n = 1; n < n_fat; n++) {		/* This loop may take a time on FAT32 volume due to many single sector writes */
+			if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
+				return FR_DISK_ERR;
+		}
+	}
+
+	/* Initialize root directory */
+	i = (fmt == FS_FAT32) ? au : (UINT)n_dir;
+	do {
+		if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
+			return FR_DISK_ERR;
+	} while (--i);
+
+#if _USE_TRIM	/* Erase data area if needed */
+	{
+		eb[0] = wsect; eb[1] = wsect + (n_clst - ((fmt == FS_FAT32) ? 1 : 0)) * au - 1;
+		disk_ioctl(pdrv, CTRL_TRIM, eb);
+	}
 #endif
 
-    /* Create FSInfo if needed */
-    if (fmt == FS_FAT32) {
-        ST_DWORD(tbl+FSI_LeadSig, 0x41615252);
-        ST_DWORD(tbl+FSI_StrucSig, 0x61417272);
-        ST_DWORD(tbl+FSI_Free_Count, n_clst - 1);   /* Number of free clusters */
-        ST_DWORD(tbl+FSI_Nxt_Free, 2);              /* Last allocated cluster# */
-        ST_WORD(tbl+BS_55AA, 0xAA55);
-        disk_write(pdrv, tbl, b_vol + 1, 1);    /* Write original (VBR+1) */
-        disk_write(pdrv, tbl, b_vol + 7, 1);    /* Write backup (VBR+7) */
-    }
-
-    return (disk_ioctl(pdrv, CTRL_SYNC, 0) == RES_OK) ? FR_OK : FR_DISK_ERR;
+	/* Create FSINFO if needed */
+	if (fmt == FS_FAT32) {
+		ST_DWORD(tbl + FSI_LeadSig, 0x41615252);
+		ST_DWORD(tbl + FSI_StrucSig, 0x61417272);
+		ST_DWORD(tbl + FSI_Free_Count, n_clst - 1);	/* Number of free clusters */
+		ST_DWORD(tbl + FSI_Nxt_Free, 2);			/* Last allocated cluster# */
+		ST_WORD(tbl + BS_55AA, 0xAA55);
+		disk_write(pdrv, tbl, b_vol + 1, 1);	/* Write original (VBR + 1) */
+		disk_write(pdrv, tbl, b_vol + 7, 1);	/* Write backup (VBR + 7) */
+	}
+
+	return (disk_ioctl(pdrv, CTRL_SYNC, 0) == RES_OK) ? FR_OK : FR_DISK_ERR;
 }
 
 
-#if _MULTI_PARTITION == 2
+
+#if _MULTI_PARTITION
 /*-----------------------------------------------------------------------*/
-/* Divide Physical Drive                                                 */
+/* 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 */
+	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 CHS in the table regardless 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] <= 100) ? (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) || disk_ioctl(pdrv, CTRL_SYNC, 0)) ? FR_DISK_ERR : FR_OK;
+	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 CHS in the table regardless 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 == 2 */
+#endif /* _MULTI_PARTITION */
 #endif /* _USE_MKFS && !_FS_READONLY */
 
 
@@ -3937,95 +4350,167 @@
 /*-----------------------------------------------------------------------*/
 /* 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* fil        /* Pointer to the file object */
+	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 bytes until buffer gets filled */
-        f_read(fil, s, 1, &rc);
-        if (rc != 1) break;         /* Break on EOF or error */
-        c = s[0];
-#if _LFN_UNICODE                    /* Read a character in UTF-8 encoding */
-        if (c >= 0x80) {
-            if (c < 0xC0) continue; /* Skip stray trailer */
-            if (c < 0xE0) {         /* Two-byte sequence */
-                f_read(fil, 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(fil, 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 = '?';
-                }
-            }
-        }
+	int n = 0;
+	TCHAR c, *p = buff;
+	BYTE s[2];
+	UINT rc;
+
+
+	while (n < len - 1) {	/* Read characters until buffer gets filled */
+#if _USE_LFN && _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
-#if _USE_STRFUNC >= 2
-        if (c == '\r') continue;    /* Strip '\r' */
+#else						/* Read a character without conversion */
+		f_read(fp, s, 1, &rc);
+		if (rc != 1) break;
+		c = s[0];
 #endif
-        *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 (_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                                           */
 /*-----------------------------------------------------------------------*/
-int f_putc (
-    TCHAR c,    /* A character to be output */
-    FIL* fil    /* Pointer to the file object */
+
+typedef struct {
+	FIL* fp;
+	int idx, nchr;
+	BYTE buf[64];
+} putbuff;
+
+
+static
+void putc_bfd (
+	putbuff* pb,
+	TCHAR c
 )
 {
-    UINT bw, btw;
-    BYTE s[3];
-
-
-#if _USE_STRFUNC >= 2
-    if (c == '\n') f_putc ('\r', fil);  /* LF -> CRLF conversion */
+	UINT bw;
+	int i;
+
+
+	if (_USE_STRFUNC == 2 && c == '\n')	 /* LF -> CRLF conversion */
+		putc_bfd(pb, '\r');
+
+	i = pb->idx;	/* Buffer write index (-1:error) */
+	if (i < 0) return;
+
+#if _USE_LFN && _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
-
-#if _LFN_UNICODE    /* Write the character in UTF-8 encoding */
-    if (c < 0x80) {         /* 7-bit */
-        s[0] = (BYTE)c;
-        btw = 1;
-    } else {
-        if (c < 0x800) {    /* 11-bit */
-            s[0] = (BYTE)(0xC0 | (c >> 6));
-            s[1] = (BYTE)(0x80 | (c & 0x3F));
-            btw = 2;
-        } else {            /* 16-bit */
-            s[0] = (BYTE)(0xE0 | (c >> 12));
-            s[1] = (BYTE)(0x80 | ((c >> 6) & 0x3F));
-            s[2] = (BYTE)(0x80 | (c & 0x3F));
-            btw = 3;
-        }
-    }
-#else               /* Write the character without conversion */
-    s[0] = (BYTE)c;
-    btw = 1;
+#else							/* Write a character without conversion */
+	pb->buf[i++] = (BYTE)c;
 #endif
-    f_write(fil, s, btw, &bw);      /* Write the char to the file */
-    return (bw == btw) ? 1 : EOF;   /* Return the result */
+
+	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++;
+}
+
+
+
+int f_putc (
+	TCHAR c,	/* A character to be output */
+	FIL* fp		/* Pointer to the file object */
+)
+{
+	putbuff pb;
+	UINT nw;
+
+
+	pb.fp = fp;			/* Initialize output buffer */
+	pb.nchr = pb.idx = 0;
+
+	putc_bfd(&pb, c);	/* Put a character */
+
+	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;
 }
 
 
@@ -4034,18 +4519,26 @@
 /*-----------------------------------------------------------------------*/
 /* Put a string to the file                                              */
 /*-----------------------------------------------------------------------*/
+
 int f_puts (
-    const TCHAR* str,   /* Pointer to the string to be output */
-    FIL* fil            /* Pointer to the file object */
+	const TCHAR* str,	/* Pointer to the string to be output */
+	FIL* fp				/* Pointer to the file object */
 )
 {
-    int n;
-
-
-    for (n = 0; *str; str++, n++) {
-        if (f_putc(*str, fil) == EOF) return EOF;
-    }
-    return n;
+	putbuff pb;
+	UINT nw;
+
+
+	pb.fp = fp;				/* Initialize output buffer */
+	pb.nchr = pb.idx = 0;
+
+	while (*str)			/* Put the string */
+		putc_bfd(&pb, *str++);
+
+	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;
 }
 
 
@@ -4054,100 +4547,104 @@
 /*-----------------------------------------------------------------------*/
 /* Put a formatted string to the file                                    */
 /*-----------------------------------------------------------------------*/
+
 int f_printf (
-    FIL* fil,           /* Pointer to the file object */
-    const TCHAR* str,   /* Pointer to the format string */
-    ...                 /* Optional arguments... */
+	FIL* fp,			/* Pointer to the file object */
+	const TCHAR* fmt,	/* Pointer to the format string */
+	...					/* Optional arguments... */
 )
 {
-    va_list arp;
-    BYTE f, r;
-    UINT i, j, w;
-    ULONG v;
-    TCHAR c, d, s[16], *p;
-    int res, chc, cc;
-
-
-    va_start(arp, str);
-
-    for (cc = res = 0; cc != EOF; res += cc) {
-        c = *str++;
-        if (c == 0) break;          /* End of string */
-        if (c != '%') {             /* Non escape character */
-            cc = f_putc(c, fil);
-            if (cc != EOF) cc = 1;
-            continue;
-        }
-        w = f = 0;
-        c = *str++;
-        if (c == '0') {             /* Flag: '0' padding */
-            f = 1; c = *str++;
-        } else {
-            if (c == '-') {         /* Flag: left justified */
-                f = 2; c = *str++;
-            }
-        }
-        while (IsDigit(c)) {        /* Precision */
-            w = w * 10 + c - '0';
-            c = *str++;
-        }
-        if (c == 'l' || c == 'L') { /* Prefix: Size is long int */
-            f |= 4; c = *str++;
-        }
-        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++) ;
-            chc = 0;
-            if (!(f & 2)) {
-                while (j++ < w) chc += (cc = f_putc(' ', fil));
-            }
-            chc += (cc = f_puts(p, fil));
-            while (j++ < w) chc += (cc = f_putc(' ', fil));
-            if (cc != EOF) cc = chc;
-            continue;
-        case 'C' :                  /* Character */
-            cc = f_putc((TCHAR)va_arg(arp, int), fil); 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) */
-            cc = f_putc(c, fil); continue;
-        }
-
-        /* Get an argument and put it in numeral */
-        v = (f & 4) ? (ULONG)va_arg(arp, long) : ((d == 'D') ? (ULONG)(long)va_arg(arp, int) : (ULONG)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;
-            s[i++] = d + '0';
-        } while (v && i < sizeof s / sizeof s[0]);
-        if (f & 8) s[i++] = '-';
-        j = i; d = (f & 1) ? '0' : ' ';
-        res = 0;
-        while (!(f & 2) && j++ < w) res += (cc = f_putc(d, fil));
-        do res += (cc = f_putc(s[--i], fil)); while(i);
-        while (j++ < w) res += (cc = f_putc(' ', fil));
-        if (cc != EOF) cc = res;
-    }
-
-    va_end(arp);
-    return (cc == EOF) ? cc : res;
+	va_list arp;
+	BYTE f, r;
+	UINT nw, i, j, w;
+	DWORD v;
+	TCHAR c, d, s[16], *p;
+	putbuff pb;
+
+
+	pb.fp = fp;				/* Initialize output buffer */
+	pb.nchr = pb.idx = 0;
+
+	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;
+			s[i++] = d + '0';
+		} while (v && i < sizeof s / sizeof s[0]);
+		if (f & 8) s[i++] = '-';
+		j = i; d = (f & 1) ? '0' : ' ';
+		while (!(f & 2) && j++ < w) putc_bfd(&pb, d);
+		do putc_bfd(&pb, s[--i]); while (i);
+		while (j++ < w) putc_bfd(&pb, d);
+	}
+
+	va_end(arp);
+
+	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;
 }
 
 #endif /* !_FS_READONLY */
 #endif /* _USE_STRFUNC */
+
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/ff.h
--- a/ChaN/ff.h	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/ff.h	Thu Aug 13 10:15:39 2015 +0100
@@ -1,29 +1,30 @@
 /*---------------------------------------------------------------------------/
-/  FatFs - FAT file system module include file  R0.09a    (C)ChaN, 2012
+/  FatFs - FAT file system module include R0.11     (C)ChaN, 2015
 /----------------------------------------------------------------------------/
-/ FatFs module is a generic FAT file system module for small embedded systems.
-/ This is a free software that opened for education, research and commercial
-/ developments under license policy of following terms.
+/ FatFs module is a free software that opened under license policy of
+/ following conditions.
+/
+/ Copyright (C) 2015, ChaN, all right reserved.
 /
-/  Copyright (C) 2012, ChaN, all right reserved.
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
 /
-/ * The FatFs module is a free software and there is NO WARRANTY.
-/ * No restriction on use. You can use, modify and redistribute it for
-/   personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
-/ * Redistributions of source code must retain the above copyright notice.
-/
-/----------------------------------------------------------------------------*/
+/ 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  4004    /* Revision ID */
+#define _FATFS	32020	/* Revision ID */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "integer.h"    /* Basic integer types */
-#include "ffconf.h"     /* FatFs configuration options */
-
+#include "integer.h"	/* Basic integer types */
+#include "ffconf.h"		/* FatFs configuration options */
 #if _FATFS != _FFCONF
 #error Wrong configuration file (ffconf.h).
 #endif
@@ -32,18 +33,18 @@
 
 /* Definitions of volume management */
 
-#if _MULTI_PARTITION        /* Multiple partition configuration */
+#if _MULTI_PARTITION		/* Multiple partition configuration */
 typedef struct {
-    BYTE pd;    /* Physical drive number */
-    BYTE pt;    /* Partition: 0:Auto detect, 1-4:Forced partition) */
+	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 */
+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            /* Always mounts the 1st partition or in SFD */
+#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
 
@@ -51,9 +52,9 @@
 
 /* Type of path name strings on FatFs API */
 
-#if _LFN_UNICODE            /* Unicode string */
+#if _LFN_UNICODE			/* Unicode string */
 #if !_USE_LFN
-#error _LFN_UNICODE must be 0 in non-LFN cfg.
+#error _LFN_UNICODE must be 0 at non-LFN cfg.
 #endif
 #ifndef _INC_TCHAR
 typedef WCHAR TCHAR;
@@ -61,7 +62,7 @@
 #define _TEXT(x) L ## x
 #endif
 
-#else                       /* ANSI/OEM string */
+#else						/* ANSI/OEM string */
 #ifndef _INC_TCHAR
 typedef char TCHAR;
 #define _T(x) x
@@ -75,35 +76,35 @@
 /* File system object structure (FATFS) */
 
 typedef struct {
-    BYTE    fs_type;        /* FAT sub-type (0:Not mounted) */
-    BYTE    drv;            /* Physical drive number */
-    BYTE    csize;          /* Sectors per cluster (1,2,4...128) */
-    BYTE    n_fats;         /* Number of FAT copies (1,2) */
-    BYTE    wflag;          /* win[] dirty flag (1:must be written back) */
-    BYTE    fsi_flag;       /* fsinfo dirty flag (1:must be written back) */
-    WORD    id;             /* File system mount ID */
-    WORD    n_rootdir;      /* Number of root directory entries (FAT12/16) */
-#if _MAX_SS != 512
-    WORD    ssize;          /* Bytes per sector (512, 1024, 2048 or 4096) */
+	BYTE	fs_type;		/* FAT sub-type (0:Not mounted) */
+	BYTE	drv;			/* Physical drive number */
+	BYTE	csize;			/* Sectors per cluster (1,2,4...128) */
+	BYTE	n_fats;			/* Number of FAT copies (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) */
+#if _MAX_SS != _MIN_SS
+	WORD	ssize;			/* Bytes per sector (512, 1024, 2048 or 4096) */
 #endif
 #if _FS_REENTRANT
-    _SYNC_t sobj;           /* Identifier of sync object */
+	_SYNC_t	sobj;			/* Identifier of sync object */
 #endif
 #if !_FS_READONLY
-    DWORD   last_clust;     /* Last allocated cluster */
-    DWORD   free_clust;     /* Number of free clusters */
-    DWORD   fsi_sector;     /* fsinfo sector (FAT32) */
+	DWORD	last_clust;		/* Last allocated cluster */
+	DWORD	free_clust;		/* Number of free clusters */
 #endif
 #if _FS_RPATH
-    DWORD   cdir;           /* Current directory start cluster (0:root) */
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
 #endif
-    DWORD   n_fatent;       /* Number of FAT entries (= number of clusters + 2) */
-    DWORD   fsize;          /* Sectors per FAT */
-    DWORD   fatbase;        /* FAT start sector */
-    DWORD   dirbase;        /* Root directory start sector (FAT32:Cluster#) */
-    DWORD   database;       /* Data start sector */
-    DWORD   winsect;        /* Current sector appearing in the win[] */
-    BYTE    win[_MAX_SS];   /* Disk access window for Directory, FAT (and Data on tiny cfg) */
+	DWORD	n_fatent;		/* Number of FAT entries, = number of clusters + 2 */
+	DWORD	fsize;			/* Sectors per FAT */
+	DWORD	volbase;		/* Volume start sector */
+	DWORD	fatbase;		/* FAT start sector */
+	DWORD	dirbase;		/* Root directory start sector (FAT32:Cluster#) */
+	DWORD	database;		/* Data start 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;
 
 
@@ -111,62 +112,68 @@
 /* File object structure (FIL) */
 
 typedef struct {
-    FATFS*  fs;             /* Pointer to the related file system object */
-    WORD    id;             /* File system mount ID of the related file system object */
-    BYTE    flag;           /* File status flags */
-    BYTE    pad1;
-    DWORD   fptr;           /* File read/write pointer (0ed on file open) */
-    DWORD   fsize;          /* File size */
-    DWORD   sclust;         /* File data start cluster (0:no data cluster, always 0 when fsize is 0) */
-    DWORD   clust;          /* Current cluster of fpter */
-    DWORD   dsect;          /* Current data sector of fpter */
+	FATFS*	fs;				/* Pointer to the related file system object (**do not change order**) */
+	WORD	id;				/* Owner file system mount ID (**do not change order**) */
+	BYTE	flag;			/* Status flags */
+	BYTE	err;			/* Abort flag (error code) */
+	DWORD	fptr;			/* File read/write pointer (Zeroed on file open) */
+	DWORD	fsize;			/* File size */
+	DWORD	sclust;			/* File start cluster (0:no cluster chain, always 0 when fsize is 0) */
+	DWORD	clust;			/* Current cluster of fpter (not valid when fprt is 0) */
+	DWORD	dsect;			/* Sector number appearing in buf[] (0:invalid) */
 #if !_FS_READONLY
-    DWORD   dir_sect;       /* Sector containing the directory entry */
-    BYTE*   dir_ptr;        /* Pointer to the directory entry in the window */
+	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 (null on file open) */
+	DWORD*	cltbl;			/* Pointer to the cluster link map table (Nulled on file open) */
 #endif
 #if _FS_LOCK
-    UINT    lockid;         /* File lock ID (index of file semaphore table Files[]) */
+	UINT	lockid;			/* File lock ID origin from 1 (index of file semaphore table Files[]) */
 #endif
 #if !_FS_TINY
-    BYTE    buf[_MAX_SS];   /* File data read/write buffer */
+	BYTE	buf[_MAX_SS];	/* File private data read/write window */
 #endif
 } FIL;
 
 
 
-/* Directory object structure (DIR) */
+/* Directory object structure (FATFS_DIR) */
 
 typedef struct {
-    FATFS*  fs;             /* Pointer to the owner file system object */
-    WORD    id;             /* Owner file system mount ID */
-    WORD    index;          /* Current read/write index number */
-    DWORD   sclust;         /* Table start cluster (0:Root dir) */
-    DWORD   clust;          /* Current cluster */
-    DWORD   sect;           /* Current sector */
-    BYTE*   dir;            /* Pointer to the current SFN entry in the win[] */
-    BYTE*   fn;             /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+	FATFS*	fs;				/* Pointer to the owner file system object (**do not change order**) */
+	WORD	id;				/* Owner file system mount ID (**do not change order**) */
+	WORD	index;			/* Current read/write index number */
+	DWORD	sclust;			/* Table start cluster (0:Root FATFS_DIR) */
+	DWORD	clust;			/* Current cluster */
+	DWORD	sect;			/* Current sector */
+	BYTE*	FATFS_DIR;			/* Pointer to the current SFN entry in the win[] */
+	BYTE*	fn;				/* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+#if _FS_LOCK
+	UINT	lockid;			/* File lock ID (index of file semaphore table Files[]) */
+#endif
 #if _USE_LFN
-    WCHAR*  lfn;            /* Pointer to the LFN working buffer */
-    WORD    lfn_idx;        /* Last matched LFN index number (0xFFFF:No LFN) */
+	WCHAR*	lfn;			/* Pointer to the LFN working buffer */
+	WORD	lfn_idx;		/* Last matched LFN index number (0xFFFF:No LFN) */
+#endif
+#if _USE_FIND
+	const TCHAR*	pat;	/* Pointer to the name matching pattern */
 #endif
 } FATFS_DIR;
 
 
 
-/* File status structure (FILINFO) */
+/* File information structure (FILINFO) */
 
 typedef struct {
-    DWORD   fsize;          /* File size */
-    WORD    fdate;          /* Last modified date */
-    WORD    ftime;          /* Last modified time */
-    BYTE    fattrib;        /* Attribute */
-    TCHAR   fname[13];      /* Short file name (8.3 format) */
+	DWORD	fsize;			/* File size */
+	WORD	fdate;			/* Last modified date */
+	WORD	ftime;			/* Last modified time */
+	BYTE	fattrib;		/* Attribute */
+	TCHAR	fname[13];		/* Short file name (8.3 format) */
 #if _USE_LFN
-    TCHAR*  lfname;         /* Pointer to the LFN buffer */
-    UINT    lfsize;         /* Size of LFN buffer in TCHAR */
+	TCHAR*	lfname;			/* Pointer to the LFN buffer */
+	UINT 	lfsize;			/* Size of LFN buffer in TCHAR */
 #endif
 } FILINFO;
 
@@ -175,26 +182,26 @@
 /* File function return code (FRESULT) */
 
 typedef enum {
-    FR_OK = 0,              /* (0) Succeeded */
-    FR_DISK_ERR,            /* (1) A hard error occurred in the low level disk I/O layer */
-    FR_INT_ERR,             /* (2) Assertion failed */
-    FR_NOT_READY,           /* (3) The physical drive cannot work */
-    FR_NO_FILE,             /* (4) Could not find the file */
-    FR_NO_PATH,             /* (5) Could not find the path */
-    FR_INVALID_NAME,        /* (6) The path name format is invalid */
-    FR_DENIED,              /* (7) Access denied due to prohibited access or directory full */
-    FR_EXIST,               /* (8) Access denied due to prohibited access */
-    FR_INVALID_OBJECT,      /* (9) The file/directory object is invalid */
-    FR_WRITE_PROTECTED,     /* (10) The physical drive is write protected */
-    FR_INVALID_DRIVE,       /* (11) The logical drive number is invalid */
-    FR_NOT_ENABLED,         /* (12) The volume has no work area */
-    FR_NO_FILESYSTEM,       /* (13) There is no valid FAT volume */
-    FR_MKFS_ABORTED,        /* (14) The f_mkfs() aborted due to any parameter error */
-    FR_TIMEOUT,             /* (15) Could not get a grant to access the volume within defined period */
-    FR_LOCKED,              /* (16) The operation is rejected according to the file sharing policy */
-    FR_NOT_ENOUGH_CORE,     /* (17) LFN working buffer could not be allocated */
-    FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_SHARE */
-    FR_INVALID_PARAMETER    /* (19) Given parameter is invalid */
+	FR_OK = 0,				/* (0) Succeeded */
+	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
+	FR_INT_ERR,				/* (2) Assertion failed */
+	FR_NOT_READY,			/* (3) The physical drive cannot work */
+	FR_NO_FILE,				/* (4) Could not find the file */
+	FR_NO_PATH,				/* (5) Could not find the path */
+	FR_INVALID_NAME,		/* (6) The path name format is invalid */
+	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
+	FR_EXIST,				/* (8) Access denied due to prohibited access */
+	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
+	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
+	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
+	FR_NOT_ENABLED,			/* (12) The volume has no work area */
+	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
+	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any parameter error */
+	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
+	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
+	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
+	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > _FS_SHARE */
+	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
 } FRESULT;
 
 
@@ -202,38 +209,45 @@
 /*--------------------------------------------------------------*/
 /* FatFs module application interface                           */
 
-FRESULT f_mount (BYTE, FATFS*);                     /* Mount/Unmount a logical drive */
-FRESULT f_open (FIL*, const TCHAR*, BYTE);          /* Open or create a file */
-FRESULT f_read (FIL*, void*, UINT, UINT*);          /* Read data from a file */
-FRESULT f_lseek (FIL*, DWORD);                      /* Move file pointer of a file object */
-FRESULT f_close (FIL*);                             /* Close an open file object */
-FRESULT f_opendir (FATFS_DIR*, const TCHAR*);             /* Open an existing directory */
-FRESULT f_readdir (FATFS_DIR*, FILINFO*);                 /* Read a directory item */
-FRESULT f_stat (const TCHAR*, FILINFO*);            /* Get file status */
-FRESULT f_write (FIL*, const void*, UINT, UINT*);   /* Write data to a file */
-FRESULT f_getfree (const TCHAR*, DWORD*, FATFS**);  /* Get number of free clusters on the drive */
-FRESULT f_truncate (FIL*);                          /* Truncate file */
-FRESULT f_sync (FIL*);                              /* Flush cached data of a writing file */
-FRESULT f_unlink (const TCHAR*);                    /* Delete an existing file or directory */
-FRESULT f_mkdir (const TCHAR*);                     /* Create a new directory */
-FRESULT f_chmod (const TCHAR*, BYTE, BYTE);         /* Change attribute of the file/dir */
-FRESULT f_utime (const TCHAR*, const FILINFO*);     /* Change times-tamp of the file/dir */
-FRESULT f_rename (const TCHAR*, const TCHAR*);      /* Rename/Move a file or directory */
-FRESULT f_chdrive (BYTE);                           /* Change current drive */
-FRESULT f_chdir (const TCHAR*);                     /* Change current directory */
-FRESULT f_getcwd (TCHAR*, UINT);                    /* Get current directory */
-FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*);   /* Forward data to the stream */
-FRESULT f_mkfs (BYTE, BYTE, UINT);                  /* Create a file system on the drive */
-FRESULT f_fdisk (BYTE, const DWORD[], void*);       /* Divide a physical drive into some partitions */
-int f_putc (TCHAR, FIL*);                           /* Put a character to the file */
-int f_puts (const TCHAR*, FIL*);                    /* Put a string to the file */
-int f_printf (FIL*, const TCHAR*, ...);             /* Put a formatted string to the file */
-TCHAR* f_gets (TCHAR*, int, FIL*);                  /* Get a string from the file */
+FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
+FRESULT f_close (FIL* fp);											/* Close an open file object */
+FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from a file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to a file */
+FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
+FRESULT f_lseek (FIL* fp, DWORD ofs);								/* Move file pointer of a file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of a writing file */
+FRESULT f_opendir (FATFS_DIR* dp, const TCHAR* path);						/* Open a directory */
+FRESULT f_closedir (FATFS_DIR* dp);										/* Close an open directory */
+FRESULT f_readdir (FATFS_DIR* dp, FILINFO* fno);							/* Read a directory item */
+FRESULT f_findfirst (FATFS_DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
+FRESULT f_findnext (FATFS_DIR* dp, FILINFO* fno);							/* Find next file */
+FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
+FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
+FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
+FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
+FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of the file/FATFS_DIR */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change times-tamp of the file/FATFS_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_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
+FRESULT f_mkfs (const TCHAR* path, BYTE sfd, UINT au);				/* Create a file system on the volume */
+FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work);			/* Divide a physical drive into some partitions */
+int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
+int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
+int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
+TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
 
-#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
-#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
+#define f_eof(fp) ((int)((fp)->fptr == (fp)->fsize))
+#define f_error(fp) ((fp)->err)
 #define f_tell(fp) ((fp)->fptr)
 #define f_size(fp) ((fp)->fsize)
+#define f_rewind(fp) f_lseek((fp), 0)
+#define f_rewinddir(dp) f_readdir((dp), 0)
 
 #ifndef EOF
 #define EOF (-1)
@@ -246,26 +260,26 @@
 /* Additional user defined functions                            */
 
 /* RTC function */
-#if !_FS_READONLY
+#if !_FS_READONLY && !_FS_NORTC
 DWORD get_fattime (void);
 #endif
 
 /* Unicode support functions */
-#if _USE_LFN                        /* Unicode - OEM code conversion */
-WCHAR ff_convert (WCHAR, UINT);     /* OEM-Unicode bidirectional conversion */
-WCHAR ff_wtoupper (WCHAR);          /* Unicode upper-case conversion */
-#if _USE_LFN == 3                   /* Memory functions */
-void* ff_memalloc (UINT);           /* Allocate memory block */
-void ff_memfree (void*);            /* Free memory block */
+#if _USE_LFN							/* Unicode - OEM code conversion */
+WCHAR ff_convert (WCHAR chr, UINT FATFS_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, _SYNC_t*);/* Create a sync object */
-int ff_req_grant (_SYNC_t);         /* Lock sync object */
-void ff_rel_grant (_SYNC_t);        /* Unlock sync object */
-int ff_del_syncobj (_SYNC_t);       /* Delete a sync object */
+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
 
 
@@ -277,57 +291,56 @@
 
 /* File access control and file status flags (FIL.flag) */
 
-#define FA_READ             0x01
-#define FA_OPEN_EXISTING    0x00
-#define FA__ERROR           0x80
+#define	FA_READ				0x01
+#define	FA_OPEN_EXISTING	0x00
 
 #if !_FS_READONLY
-#define FA_WRITE            0x02
-#define FA_CREATE_NEW       0x04
-#define FA_CREATE_ALWAYS    0x08
-#define FA_OPEN_ALWAYS      0x10
-#define FA__WRITTEN         0x20
-#define FA__DIRTY           0x40
+#define	FA_WRITE			0x02
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define FA__WRITTEN			0x20
+#define FA__DIRTY			0x40
 #endif
 
 
 /* FAT sub type (FATFS.fs_type) */
 
-#define FS_FAT12    1
-#define FS_FAT16    2
-#define FS_FAT32    3
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
 
 
 /* File attribute bits for directory entry */
 
-#define AM_RDO  0x01    /* Read only */
-#define AM_HID  0x02    /* Hidden */
-#define AM_SYS  0x04    /* System */
-#define AM_VOL  0x08    /* Volume label */
-#define AM_LFN  0x0F    /* LFN entry */
-#define AM_DIR  0x10    /* Directory */
-#define AM_ARC  0x20    /* Archive */
-#define AM_MASK 0x3F    /* Mask of defined bits */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define	AM_VOL	0x08	/* Volume label */
+#define AM_LFN	0x0F	/* LFN entry */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+#define AM_MASK	0x3F	/* Mask of defined bits */
 
 
 /* Fast seek feature */
-#define CREATE_LINKMAP  0xFFFFFFFF
+#define CREATE_LINKMAP	0xFFFFFFFF
 
 
 
 /*--------------------------------*/
 /* Multi-byte word access macros  */
 
-#if _WORD_ACCESS == 1   /* Enable word access to the FAT structure */
-#define LD_WORD(ptr)        (WORD)(*(WORD*)(BYTE*)(ptr))
-#define LD_DWORD(ptr)       (DWORD)(*(DWORD*)(BYTE*)(ptr))
-#define ST_WORD(ptr,val)    *(WORD*)(BYTE*)(ptr)=(WORD)(val)
-#define ST_DWORD(ptr,val)   *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
-#else                   /* Use byte-by-byte access to the FAT structure */
-#define LD_WORD(ptr)        (WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
-#define LD_DWORD(ptr)       (DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))
-#define ST_WORD(ptr,val)    *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)
-#define ST_DWORD(ptr,val)   *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)
+#if _WORD_ACCESS == 1	/* Enable word access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(*(WORD*)(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(*(DWORD*)(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(WORD*)(BYTE*)(ptr)=(WORD)(val)
+#define	ST_DWORD(ptr,val)	*(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
+#else					/* Use byte-by-byte access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)
+#define	ST_DWORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)
 #endif
 
 #ifdef __cplusplus
@@ -335,3 +348,4 @@
 #endif
 
 #endif /* _FATFS */
+
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/ffconf.h
--- a/ChaN/ffconf.h	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/ffconf.h	Thu Aug 13 10:15:39 2015 +0100
@@ -1,191 +1,275 @@
 /*---------------------------------------------------------------------------/
-/  FatFs - FAT file system module configuration file  R0.09a (C)ChaN, 2012
-/----------------------------------------------------------------------------/
-/
-/ CAUTION! Do not forget to make clean the project after any changes to
-/ the configuration options.
-/
-/----------------------------------------------------------------------------*/
-#ifndef _FFCONF
-#define _FFCONF 4004    /* Revision ID */
+/  FatFs - FAT file system module configuration file  R0.11 (C)ChaN, 2015
+/---------------------------------------------------------------------------*/
 
-#define FFS_DBG     0
+#define _FFCONF 32020	/* Revision ID */
+
+#define FFS_DBG			0
 
 /*---------------------------------------------------------------------------/
 / Functions and Buffer Configurations
-/----------------------------------------------------------------------------*/
+/---------------------------------------------------------------------------*/
 
-#define _FS_TINY        0   /* 0:Normal or 1:Tiny */
-/* When _FS_TINY is set to 1, FatFs uses the sector buffer in the file system
-/  object instead of the sector buffer in the individual file object for file
-/  data transfer. This reduces memory consumption 512 bytes each file object. */
+#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_READONLY    0   /* 0:Read/Write or 1:Read only */
-/* Setting _FS_READONLY to 1 defines read only configuration. This removes
-/  writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,
-/  f_truncate and useless f_getfree. */
+#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_chmod(), f_utime(),
+/      f_truncate() and f_rename() function 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 _FS_MINIMIZE    0   /* 0 to 3 */
-/* The _FS_MINIMIZE option defines minimization level to remove some functions.
+#define	_USE_STRFUNC	0
+/* This option switches string functions, f_gets(), f_putc(), f_puts() and
+/  f_printf().
 /
-/   0: Full function.
-/   1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename
-/      are removed.
-/   2: f_opendir and f_readdir are removed in addition to 1.
-/   3: f_lseek is removed in addition to 2. */
+/  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 feature and related functions,
+/  f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */
 
 
-#define _USE_STRFUNC    0   /* 0:Disable or 1-2:Enable */
-/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+#define	_USE_MKFS		1
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
 
 
-#define _USE_MKFS       1   /* 0:Disable or 1:Enable */
-/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */
+#define	_USE_FASTSEEK	0
+/* This option switches fast seek feature. (0:Disable or 1:Enable) */
 
 
-#define _USE_FORWARD    0   /* 0:Disable or 1:Enable */
-/* To enable f_forward function, set _USE_FORWARD to 1 and set _FS_TINY to 1. */
+#define _USE_LABEL		0
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
 
 
-#define _USE_FASTSEEK   0   /* 0:Disable or 1:Enable */
-/* To enable fast seek feature, set _USE_FASTSEEK to 1. */
-
+#define	_USE_FORWARD	0
+/* This option switches f_forward() function. (0:Disable or 1:Enable)
+/  To enable it, also _FS_TINY need to be set to 1. */
 
 
 /*---------------------------------------------------------------------------/
 / Locale and Namespace Configurations
-/----------------------------------------------------------------------------*/
+/---------------------------------------------------------------------------*/
 
-#define _CODE_PAGE  858
-/* The _CODE_PAGE specifies the OEM code page to be used on the target system.
+#define _CODE_PAGE	858
+/* 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.
 /
-/   932  - Japanese Shift-JIS (DBCS, OEM, Windows)
-/   936  - Simplified Chinese GBK (DBCS, OEM, Windows)
-/   949  - Korean (DBCS, OEM, Windows)
-/   950  - Traditional Chinese Big5 (DBCS, OEM, Windows)
-/   1250 - Central Europe (Windows)
-/   1251 - Cyrillic (Windows)
-/   1252 - Latin 1 (Windows)
-/   1253 - Greek (Windows)
-/   1254 - Turkish (Windows)
-/   1255 - Hebrew (Windows)
-/   1256 - Arabic (Windows)
-/   1257 - Baltic (Windows)
-/   1258 - Vietnam (OEM, Windows)
-/   437  - U.S. (OEM)
-/   720  - Arabic (OEM)
-/   737  - Greek (OEM)
-/   775  - Baltic (OEM)
-/   850  - Multilingual Latin 1 (OEM)
-/   858  - Multilingual Latin 1 + Euro (OEM)
-/   852  - Latin 2 (OEM)
-/   855  - Cyrillic (OEM)
-/   866  - Russian (OEM)
-/   857  - Turkish (OEM)
-/   862  - Hebrew (OEM)
-/   874  - Thai (OEM, Windows)
-/   1    - ASCII only (Valid for non LFN cfg.)
+/   1    - ASCII (No extended character. Non-LFN cfg. only)
+/   437  - U.S.
+/   720  - Arabic
+/   737  - Greek
+/   775  - Baltic
+/   850  - Multilingual Latin 1
+/   852  - Latin 2
+/   855  - Cyrillic
+/   857  - Turkish
+/   858  - Multilingual Latin 1 + Euro
+/   862  - Hebrew
+/   866  - Russian
+/   874  - Thai
+/   932  - Japanese Shift_JIS (DBCS)
+/   936  - Simplified Chinese GBK (DBCS)
+/   949  - Korean (DBCS)
+/   950  - Traditional Chinese Big5 (DBCS)
 */
 
 
-#define _USE_LFN    1       /* 0 to 3 */
-#define _MAX_LFN    255     /* Maximum LFN length to handle (12 to 255) */
-/* The _USE_LFN option switches the LFN support.
+#define	_USE_LFN	1
+#define	_MAX_LFN	255
+/* The _USE_LFN option switches the LFN feature.
 /
-/   0: Disable LFN feature. _MAX_LFN and _LFN_UNICODE have no effect.
-/   1: Enable LFN with static working buffer on the BSS. Always NOT reentrant.
+/   0: Disable LFN feature. _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.
 /
-/  The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes. To enable LFN,
-/  Unicode handling functions ff_convert() and ff_wtoupper() must be added
-/  to the project. When enable to use heap, memory control functions
-/  ff_memalloc() and ff_memfree() must be added to the project. */
+/  When enable the LFN feature, Unicode handling functions (option/unicode.c) must
+/  be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree(), must be added to the project. */
+
+
+#define	_LFN_UNICODE	0
+/* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)
+/  To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE
+/  to 1. This option also affects behavior of string I/O functions. */
 
 
-#define _LFN_UNICODE    0   /* 0:ANSI/OEM or 1:Unicode */
-/* To switch the character code set on FatFs API to Unicode,
-/  enable LFN feature and set _LFN_UNICODE to 1. */
+#define _STRF_ENCODE	3
+/* When _LFN_UNICODE is 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
+/
+/  When _LFN_UNICODE is 0, this option has no effect. */
 
 
-#define _FS_RPATH       0   /* 0 to 2 */
-/* The _FS_RPATH option configures relative path feature.
+#define _FS_RPATH	0
+/* This option configures relative path feature.
 /
 /   0: Disable relative path feature and remove related functions.
-/   1: Enable relative path. f_chdrive() and f_chdir() are available.
-/   2: f_getcwd() is available in addition to 1.
+/   1: Enable relative path feature. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
 /
-/  Note that output of the f_readdir fnction is affected by this option. */
-
+/  Note that directory items read via f_readdir() are affected by this option. */
 
 
 /*---------------------------------------------------------------------------/
-/ Physical Drive Configurations
-/----------------------------------------------------------------------------*/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
 
-#define _VOLUMES    1
+#define _VOLUMES	1
 /* Number of volumes (logical drives) to be used. */
 
 
-#define _MAX_SS     512     /* 512, 1024, 2048 or 4096 */
-/* Maximum sector size to be handled.
-/  Always set 512 for memory card and hard disk but a larger value may be
-/  required for on-board flash memory, floppy disk and optical disk.
-/  When _MAX_SS is larger than 512, it configures FatFs to variable sector size
-/  and GET_SECTOR_SIZE command must be implememted to the disk_ioctl function. */
+#define _STR_VOLUME_ID	0
+#define _VOLUME_STRS	"RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
+/* _STR_VOLUME_ID option switches string volume ID feature.
+/  When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
+/  number in the path name. _VOLUME_STRS defines the drive ID strings for each
+/  logical drives. Number of items must be equal to _VOLUMES. Valid characters for
+/  the drive ID strings are: A-Z and 0-9. */
+
+
+#define	_MULTI_PARTITION	0
+/* This option switches multi-partition feature. 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 feature is enabled (1),
+/  each logical drive number is bound to arbitrary physical drive and partition
+/  listed in the VolToPart[]. Also f_fdisk() funciton will be available. */
 
 
-#define _MULTI_PARTITION    0   /* 0:Single partition, 1/2:Enable multiple partition */
-/* When set to 0, each volume is bound to the same physical drive number and
-/ it can mount only first primaly partition. When it is set to 1, each volume
-/ is tied to the partitions listed in VolToPart[]. */
+#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_ERASE  0   /* 0:Disable or 1:Enable */
-/* To enable sector erase feature, set _USE_ERASE to 1. CTRL_ERASE_SECTOR command
-/  should be added to the disk_ioctl functio. */
+#define	_USE_TRIM	0
+/* This option switches ATA-TRIM feature. (0:Disable or 1:Enable)
+/  To enable Trim feature, 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 _WORD_ACCESS    0   /* 0 or 1 */
-/* Set 0 first and it is always compatible with all platforms. The _WORD_ACCESS
-/  option defines which access method is used to the word data on the FAT volume.
+#define _FS_NORTC	0
+#define _NORTC_MON	2
+#define _NORTC_MDAY	1
+#define _NORTC_YEAR	2015
+/* The _FS_NORTC option switches timestamp feature. If the system does not have
+/  an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable
+/  the timestamp feature. All objects modified by FatFs will have a fixed timestamp
+/  defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR.
+/  When timestamp feature is enabled (_FS_NORTC	== 0), get_fattime() function need
+/  to be added to the project to read current time form RTC. _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 _FS_LOCK option switches file lock feature to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when _FS_READONLY
+/  is 1.
 /
-/   0: Byte-by-byte access.
-/   1: Word access. Do not choose this unless following condition is met.
-/
-/  When the byte order on the memory is big-endian or address miss-aligned word
-/  access results incorrect behavior, the _WORD_ACCESS must be set to 0.
-/  If it is not the case, the value can also be set to 1 to improve the
-/  performance and code size.
-*/
+/  0:  Disable file lock feature. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock feature. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      lock feature is independent of re-entrancy. */
 
 
-/* A header file that defines sync object types on the O/S, such as
-/  windows.h, ucos_ii.h and semphr.h, must be included prior to ff.h. */
-
-#define _FS_REENTRANT   0       /* 0:Disable or 1:Enable */
-#define _FS_TIMEOUT     1000    /* Timeout period in unit of time ticks */
-#define _SYNC_t         HANDLE  /* O/S dependent type of sync object. e.g. HANDLE, OS_EVENT*, ID and etc.. */
-
-/* The _FS_REENTRANT option switches the reentrancy (thread safe) of the FatFs module.
+#define _FS_REENTRANT	0
+#define _FS_TIMEOUT		1000
+#define	_SYNC_t			HANDLE
+/* The _FS_REENTRANT option 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 feature.
 /
-/   0: Disable reentrancy. _SYNC_t and _FS_TIMEOUT have no effect.
-/   1: Enable reentrancy. 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. */
+/   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. */
 
 
-#define _FS_LOCK    0   /* 0:Disable or >=1:Enable */
-/* To enable file lock control feature, set _FS_LOCK to 1 or greater.
-   The value defines how many files can be opened simultaneously. */
+#define _WORD_ACCESS	0
+/* The _WORD_ACCESS option is an only platform dependent option. It defines
+/  which access method is used to the word data on the FAT volume.
+/
+/   0: Byte-by-byte access. Always compatible with all platforms.
+/   1: Word access. Do not choose this unless under both the following conditions.
+/
+/  * Address misaligned memory access is always allowed to ALL instructions.
+/  * Byte order on the memory is little-endian.
+/
+/  If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size.
+/  Following table shows allowable settings of some processor types.
+/
+/  ARM7TDMI   0   *2          ColdFire   0    *1         V850E      0    *2
+/  Cortex-M3  0   *3          Z80        0/1             V850ES     0/1
+/  Cortex-M0  0   *2          x86        0/1             TLCS-870   0/1
+/  AVR        0/1             RX600(LE)  0/1             TLCS-900   0/1
+/  AVR32      0   *1          RL78       0    *2         R32C       0    *2
+/  PIC18      0/1             SH-2       0    *1         M16C       0/1
+/  PIC24      0   *2          H8S        0    *1         MSP430     0    *2
+/  PIC32      0   *1          H8/300H    0    *1         8051       0/1
+/
+/  *1:Big-endian.
+/  *2:Unaligned memory access is not supported.
+/  *3:Some compilers generate LDM/STM for mem_cpy function.
+*/
 
 #define FLUSH_ON_NEW_CLUSTER    0   /* Sync the file on every new cluster */
 #define FLUSH_ON_NEW_SECTOR     1   /* Sync the file on every new sector */
@@ -194,5 +278,3 @@
    Clusters are group of sectors (eg: 8 sectors). Flushing on new cluster means
    it would be less often than flushing on new sector. Sectors are generally
    512 Bytes long. */
-
-#endif /* _FFCONFIG */
diff -r 3ff2606d5713 -r b3b3370574cf ChaN/integer.h
--- a/ChaN/integer.h	Thu Aug 28 13:15:31 2014 +0100
+++ b/ChaN/integer.h	Thu Aug 13 10:15:39 2015 +0100
@@ -2,36 +2,33 @@
 /* Integer type definitions for FatFs module */
 /*-------------------------------------------*/
 
-#ifndef _INTEGER
-#define _INTEGER
+#ifndef _FF_INTEGER
+#define _FF_INTEGER
 
-#ifdef _WIN32    /* FatFs development platform */
+#ifdef _WIN32	/* FatFs development platform */
 
 #include <windows.h>
 #include <tchar.h>
 
-#else            /* Embedded platform */
+#else			/* Embedded platform */
 
-/* These types must be 16-bit, 32-bit or larger integer */
-typedef int             INT;
-typedef unsigned int    UINT;
-
-/* These types must be 8-bit integer */
-typedef char            CHAR;
-typedef unsigned char   UCHAR;
-typedef unsigned char   BYTE;
+/* This type MUST be 8 bit */
+typedef unsigned char	BYTE;
 
-/* These types must be 16-bit integer */
-typedef short           SHORT;
-typedef unsigned short  USHORT;
-typedef unsigned short  WORD;
-typedef unsigned short  WCHAR;
+/* These types MUST be 16 bit */
+typedef short			SHORT;
+typedef unsigned short	WORD;
+typedef unsigned short	WCHAR;
 
-/* These types must be 32-bit integer */
-typedef long            LONG;
-typedef unsigned long   ULONG;
-typedef unsigned long   DWORD;
+/* These types MUST be 16 bit or 32 bit */
+typedef int				INT;
+typedef unsigned int	UINT;
+
+/* These types MUST be 32 bit */
+typedef long			LONG;
+typedef unsigned long	DWORD;
 
 #endif
 
 #endif
+
diff -r 3ff2606d5713 -r b3b3370574cf FATDirHandle.cpp
--- a/FATDirHandle.cpp	Thu Aug 28 13:15:31 2014 +0100
+++ b/FATDirHandle.cpp	Thu Aug 13 10:15:39 2015 +0100
@@ -30,8 +30,9 @@
 }
 
 int FATDirHandle::closedir() {
+    int retval = f_closedir(&dir);
     delete this;
-    return 0;
+    return retval;
 }
 
 struct dirent *FATDirHandle::readdir() {
diff -r 3ff2606d5713 -r b3b3370574cf FATFileSystem.cpp
--- a/FATFileSystem.cpp	Thu Aug 28 13:15:31 2014 +0100
+++ b/FATFileSystem.cpp	Thu Aug 13 10:15:39 2015 +0100
@@ -47,9 +47,10 @@
     for(int i=0; i<_VOLUMES; i++) {
         if(_ffs[i] == 0) {
             _ffs[i] = this;
-            _fsid = i;
-            debug_if(FFS_DBG, "Mounting [%s] on ffs drive [%d]\n", _name, _fsid);
-            f_mount(i, &_fs);
+            _fsid[0] = '0' + i;
+            _fsid[1] = '\0';
+            debug_if(FFS_DBG, "Mounting [%s] on ffs drive [%s]\n", _name, _fsid);
+            f_mount(&_fs, _fsid, 0);
             return;
         }
     }
@@ -60,15 +61,15 @@
     for (int i=0; i<_VOLUMES; i++) {
         if (_ffs[i] == this) {
             _ffs[i] = 0;
-            f_mount(i, NULL);
+            f_mount(NULL, _fsid, 0);
         }
     }
 }
 
 FileHandle *FATFileSystem::open(const char* name, int flags) {
-    debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%d]\n", name, _name, _fsid);
+    debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%s]\n", name, _name, _fsid);
     char n[64];
-    sprintf(n, "%d:/%s", _fsid, name);
+    sprintf(n, "%s:/%s", _fsid, name);
 
     /* POSIX flags -> FatFS open mode */
     BYTE openmode;
@@ -141,13 +142,13 @@
 }
 
 int FATFileSystem::mount() {
-    FRESULT res = f_mount(_fsid, &_fs);
+    FRESULT res = f_mount(&_fs, _fsid, 1);
     return res == 0 ? 0 : -1;
 }
 
 int FATFileSystem::unmount() {
     if (disk_sync())
         return -1;
-    FRESULT res = f_mount(_fsid, NULL);
+    FRESULT res = f_mount(NULL, _fsid, 0);
     return res == 0 ? 0 : -1;
 }
diff -r 3ff2606d5713 -r b3b3370574cf FATFileSystem.h
--- a/FATFileSystem.h	Thu Aug 28 13:15:31 2014 +0100
+++ b/FATFileSystem.h	Thu Aug 13 10:15:39 2015 +0100
@@ -40,7 +40,7 @@
 
     static FATFileSystem * _ffs[_VOLUMES];   // FATFileSystem objects, as parallel to FatFs drives array
     FATFS _fs;                               // Work area (file system object) for logical drive
-    int _fsid;
+    char _fsid[2];
 
     /**
      * Opens a file on the filesystem