diff --git a/3rdparty/petitfs-0.03/doc/00index_p.html b/3rdparty/petitfs-0.03/doc/00index_p.html
new file mode 100644
index 00000000..fe5ada00
--- /dev/null
+++ b/3rdparty/petitfs-0.03/doc/00index_p.html
@@ -0,0 +1,77 @@
+
+
+
+Petit FAT File System Module
+
+
+
+Petit FAT File System Module
+
+
+
Petit FatFs is a sub-set of FatFs module for tiny 8-bit microcontrollers. It is written in compliance with ANSI C and completely separated from the disk I/O layer. It can be incorporated into the tiny microcontrollers with limited memory even if the RAM size is less than sector size. Also full featured FAT file system module is available here ↗.
+
+
Features
+
+ Very small RAM consumption (44 bytes work area + certain stack).
+ Very small code size (2K-4K bytes).
+ FAT12, FAT16 and FAT32.
+ Single volume and Single file.
+ File write function with some restrictions.
+
+
+
Application Interface
+
Petit FatFs module provides following functions.
+
+
+
Disk I/O Interface
+
Since the Petit FatFs module is completely separated from disk I/O layer, it requires following functions to lower layer to read data from storage device. The low level disk I/O module is not a part of Petit FatFs module and it must be provided by user. The sample drivers are also available in the resources.
+
+
+
Resources
+
The Petit FatFs module is a free software and is opened for education, research and development. You can use, modify and/or redistribute it for personal, non-profit or commercial use without any restriction under your responsibility. For further information, refer to the application note.
+
+
FatFs Module Application Note
+
+
+
+Petit FatFs Module Application Note
+Basic Considerations
+The FatFs module is assuming following conditions on portability.
+
+ANSI C
+Size of integer typesinteger.h . This will not be a problem on most compilers. When any conflict with existing definitions is occured, you must resolve it with care.
+
+
+
+
+
Memory Usage (R0.03)
+
+AVR x86 Compiler gcc(WinAVR) VC6 _WORD_ACCESS 1 1 Code (default) 2100 1720 Code (!_USE_READ) -444 -246 Code (_USE_DIR) +1002 +420 Code (_USE_LSEEK) +490 +228 Code (_USE_WRITE) +518 +351 RAM (bss) 2 4 RAM (work) 42 44
+
This is the size of the Petit FatFs module itself. In addition to this, a low level disk I/O module will be required for a complete function. The size of MMC/SDC module on AVR becomes approximate 620 bytes without write function and 840 bytes with write function.
+
+
Module Size Reduction
+
Follwing table shows which function is removed by configuration options for the module size reduction.
+
+Function _USE_READ _USE_DIR _USE_LSEEK _USE_WRITE 0 0 0 0 pf_mount pf_open pf_read x pf_lseek x pf_opendir x pf_readdir x pf_write x
+
+
Performance effective file access
+
For good performance on reading a file on the small embedded system, application programmer should consider what process is done in the file system module.
+
The Petit FatFs reads the disk sectors without a sector buffer. This means the file system reads a part of the sector contains the required data every reference point even if they are in the same sector. However the generic storage device are not byte addressable so that the disk I/O layer will read the entire sector and pick up the data bytes from the read data steram.
+
When read 512 byte data from a file at a time, the data sector will be read only a time. When read that data in byte-by-byte, the data sector will be read 512 times. Therefore the byte-by-byte read request will drastically decrease the read performance. To avoid this stupid read controls, the file data should be read in long block as possible. Sector alignment access is not impotant on the Petit FatFs.
+
The tiny microcontrollers targeted by Petit FatFs has a limited size of RAM. It may not able to allocate a certain size of read buffer and most type of text processing will require byte-by-byte read operation. The Petit FatFs supports data forwarding feature for such purpose.
+
+
+
About FatFs License
+
Petit FatFs has being developped as a personal project of author, ChaN. It is free from the code anyone else wrote. Following code block shows a copy of the license document that included in the source files.
+
/*----------------------------------------------------------------------------/
+/ Petit FatFs - FAT file system module R0.03 (C)ChaN, 2014
+/-----------------------------------------------------------------------------/
+/ Petit 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 trems.
+/
+/ Copyright (C) 2014, ChaN, all right reserved.
+/
+/ * The Petit 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.
+/
+/-----------------------------------------------------------------------------/
+
Therefore FatFs license is one of the BSD-style licenses but there is a significant feature. Because FatFs is for embedded projects, the conditions of redistributions in binary form, such as embedded code, hex file, binary library and any form without source code, are not specified in order to extend usability to commercial use. The documentation of the distributions need not include about Petit FatFs and its license document, and it may also. This is equivalent to the BSD 1-Clause License. Of course Petit FatFs is compatible with the projects under GNU GPL. When redistribute the Petit FatFs with any modification, the license can also be changed to GNU GPL or BSD-style license.
+
Petit FatFs - disk_initialize
+
+
+
+
+
+
disk_initialize
+
The disk_initialize function initializes the disk drive.
+
+DSTATUS disk_initialize (void)
+
+
+
Return Values
+
The disk status is returned in combination of following flags.
+
+STA_NOINIT
+Indicates that the disk drive has not been initialized. This flag is set on: system reset, disk removal and disk_initialize function failed, and cleared on: disk_initialize function succeeded.
+STA_NODISK
+Indicates that no medium in the drive. This is always cleared on fixed disk drive. This flag is not referred by Petit FatFs.
+
+
+
Description
+
The disk_initialize function initializes the storage device. If the function succeeded, STA_NOINIT flag in the return value is cleared.
+
Petit FatFs - disk_readp
+
+
+
+
+
+
disk_readp
+
The disk_readp function reads a partial sector of the device.
+
+DRESULT disk_readp (
+ BYTE* buff , /* [OUT] Pointer to the read buffer */
+ DWORD sector , /* [IN] Sector number */
+ UINT offset , /* [IN] Byte offset in the sector to start to read */
+ UINT count /* [IN] Number of bytes to read */
+);
+
+
+
Parameters
+
+buff
+Pointer to the read buffer to store the read data. If a NULL is given, read bytes will be forwarded to the outgoing stream instead of the memory.
+sector
+Specifies the sector number to be read in logical block address (LBA).
+offset
+Specifies the byte offset in the sector to start to read. The value can be 0 to 511.
+count
+Specifies number of bytes to read. The value can be 0 to 512 and offset + count must not exceed 512.
+
+
+
Return Value
+
+RES_OK (0)
+The function succeeded.
+RES_ERROR
+Any hard error occured during the disk read operation and could not recover it.
+RES_PARERR
+Invalid parameter.
+RES_NOTRDY
+The device has not been initialized.
+
+
Petit FatFs - disk_writep
+
+
+
+
+
+
disk_writep
+
The disk_writep function writes data to the sector.
+
+DRESULT disk_writep (
+ BYTE* buff , /* [IN] Pointer to the data to be written */
+ DWORD sc , /* [IN] Sector number or Number of bytes to wtite */
+);
+
+
+
Parameters
+
+buff
+Pointer to the data to be written to the sector. If a NULL is given, the function initiate/finalize a write transaction to the sector.
+sc
+Specifies nubmer of bytes to write if buff is not a NULL. If buff is a NULL and sc is not a zero, the function initiates a write transactin to the sector. If buff and sc are zero, the function finalize the current sector write transactin.
+
+
+
Return Value
+
+RES_OK (0)
+The function succeeded.
+RES_ERROR
+Any hard error occured during the write operation and could not recover it or the medium is write protected.
+RES_PARERR
+Invalid parameter.
+RES_NOTRDY
+The device has not been initialized.
+
+
+
Description
+
A sector write operation is done in following sequence.
+
+disk_writep(0, sector_number); Initiate a sector write transaction.disk_writep(data, byte_to_write); Start to write data to the sector.disk_writep(data, byte_to_write); And data can be written upto 512 bytes with one or more calls.disk_writep(data, byte_to_write); ...disk_writep(0, 0); Finalize the write transaction. If number of bytes sent is less than 512, left bytes in the sector is filled by zero.
+
If a write transaction is in progress, disk_readp() function will fail and disk_initialize() function finalize the current write transaction.
+
+
Remarks
+
This funciton is needed when _USE_WRITE == 1 .
+
Petit FatFs - Path Names
+
+
+
+
+
+
Format of the path names
+
The path name format on the Petit FatFs module is similer to MS-DOS as follows.
+
"[/]directory /file "
+
The Petit FatFs module supports only 8.3 format file name. The sub-directories are separated with a /. The path name is terminated with a nul character, control character or white space. Heading spaces are ignored and skipped. When _USE_LCC == 1 , lower case characters are allowed for the path name.
+
The Petit FatFs module does not have a concept of current directory like OS oriented file system. All objects on the volume are always specified in full path name following from the root directory. Heading separator is ignored and it can be exist or omitted.
+
Petit FatFs - pf_lseek
+
+
+
+
+
+
pf_lseek
+
The pf_lseek function moves the file read/write pointer of the open file.
+
+
+FRESULT pf_lseek (
+ DWORD ofs /* [IN] File offset in unit of byte */
+);
+
+
+
Parameters
+
+ofs
+Number of bytes where from start of the file
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_DISK_ERR
+The function failed due to an error in the disk function, a wrong FAT structure or an internal error.
+FR_NOT_OPENED
+The file has not been opened.
+
+
+
Description
+
The pf_lseek() function moves the file read/write pointer of the open file. The offset can be specified in only origin from top of the file.
+
+
Example
+
+ /* Move to offset of 5000 from top of the file */
+ res = pf_lseek(5000);
+
+ /* Forward 3000 bytes */
+ res = pf_lseek(fs.fptr + 3000);
+
+ /* Rewind 2000 bytes (take care on wraparound) */
+ res = pf_lseek(fs.fptr - 2000);
+
+
+
QuickInfo
+
Available when _USE_LSEEK == 1 .
+
Petit FatFs - pf_mount
+
+
+
+
+
+
pf_mount
+
The pf_mount fucntion mounts a volume.
+
+FRESULT pf_mount (
+ FATFS* fs /* [IN] Pointer to the work area */
+);
+
+
+
Parameters
+
+fs
+Pointer to the work area (file system object) to be registered.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_NOT_READY
+The drive could not be initialized due to a disk error or no medium.
+FR_DISK_ERR
+An error occured in the disk function.
+FR_NO_FILESYSTEM
+There is no valid FAT partition on the disk.
+
+
+
Description
+
The pf_mount() function registers a work area to the Petit FatFs module. The volume is mounted on registration. The volume must be mounted with this function prior to any other file function and after every media changes.
+
+
QuickInfo
+
Always available.
+
Petit FatFs - pf_open
+
+
+
+
+
+
pf_open
+
The pf_open function opens an existing file.
+
+FRESULT pf_open (
+ const char* path /* [IN] Pointer to the file neme */
+);
+
+
+
Parameters
+
+path
+Pointer to a null-terminated string that specifies the file name to open.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_NO_FILE
+Could not find the file or path.
+FR_DISK_ERR
+The function failed due to a hard error in the disk function, a wrong FAT structure or an internal error.
+FR_NOT_ENABLED
+The volume has not been mounted.
+
+
+
Description
+
The file must be opend prior to use pf_read() and pf_lseek() function. The open file is valid until next open.
+
+
Example
+
+int main (void)
+{
+ FATFS fs; /* Work area (file system object) for the volume */
+ BYTE buff[16]; /* File read buffer */
+ UINT br; /* File read count */
+ FRESULT res; /* Petit FatFs function common result code */
+
+
+ /* Mount the volume */
+ pf_mount(&fs);
+ if (res) die(res);
+
+ /* Open a file */
+ res = pf_open("srcfile.dat");
+ if (res) die(res);
+
+ /* Read data to the memory */
+ res = pf_read(buff, 16, &br); /* Read data to the buff[] */
+ if (res) die(res); /* Check error */
+ if (br != 16) die(255); /* Check EOF */
+
+ ....
+
+ /* Forward data to the outgoing stream */
+ do
+ res = pf_read(0, 512, &br); /* Send data to the stream */
+ while (res || br != 512); /* Break on error or eof */
+
+ ....
+
+}
+
+
+
QuickInfo
+
Always available.
+
Petit FatFs - pf_opendir
+
+
+
+
+
+
pf_opendir
+
The pf_opendir function opens a directory.
+
+FRESULT pf_opendir (
+ DIR* dp , /* [OUT] Pointer to the blank directory object structure */
+ const char* path /* [IN] Pointer to the directory name */
+);
+
+
+
Parameters
+
+dp
+Pointer to the blank directory object to be created.
+path
+Pinter to the null-terminated string that specifies the directory name to be opened.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded and the directory object is created. It is used for subsequent calls to read the directory entries.
+FR_NO_FILE
+Could not find the path.
+FR_NOT_READY
+The disk drive cannot work due to no medium in the drive or any other reason.
+FR_DISK_ERR
+The function failed due to a hard error in the disk function, a wrong FAT structure or an internal error.
+FR_NOT_ENABLED
+The volume has no work area.
+
+
+
Description
+
The pf_opendir() function opens an exsisting directory and creates the directory object for subsequent calls. The directory object structure can be discarded at any time without any procedure.
+
+
QuickInfo
+
Available when _USE_DIR == 1 .
+
Petit FatFs - pf_read
+
+
+
+
+
+
pf_read
+
The pf_read function reads data from the file.
+
+FRESULT pf_read (
+ void* buff , /* [OUT] Pointer to the read buffer */
+ UINT btr , /* [IN] Number of bytes to read */
+ UINT* br /* [OUT] Number of bytes read */
+);
+
+
+
Parameters
+
+buff
+Pointer to the buffer to store the read data. A NULL specifies the destination is an outgoing stream.
+btr
+Number of bytes to read.
+br
+Pointer to the variable to return number of bytes read.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_DISK_ERR
+The function failed due to a hard error in the disk function, a wrong FAT structure or an internal error.
+FR_NOT_OPENED
+The file has not been opened.
+FR_NOT_ENABLED
+The volume has not been mounted.
+
+
+
Description
+
The file read/write pointer in the file system object advances in number of bytes read. After the function succeeded, *br should be checked to detect end of file. In case of *br < btr , it means the read pointer reached end of file during read operation.
+
If a NULL is given to the buff , the read bytes will be forwarded to the outgoing stream instead of the memory. The streaming function will be typically built-in the disk_readp() function.
+
+
QuickInfo
+
Available when _USE_READ == 1 .
+
Petit FatFs - pf_readdir
+
+
+
+
+
+
pf_readdir
+
The pf_readdir function reads directory entries.
+
+FRESULT pf_readdir (
+ DIR* dp , /* [IN] Pointer to the open directory object */
+ FILINFO* fno /* [OUT] Pointer to the file information structure */
+);
+
+
+
Parameters
+
+dp
+Pointer to the open directory object.
+fno
+Pointer to the file information structure to store the read item.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_DISK_ERR
+The function failed due to an error in the disk function, a wrong FAT structure or an internal error.
+FR_NOT_OPENED
+The directory object has not been opened.
+
+
+
Description
+
The pf_readdir() function reads directory entries in sequence. All items in the directory can be read by calling this function repeatedly. When all directory entries have been read and no item to read, the function returns a null string into member f_name[] in the file information structure without error. When a null pointer is given to the fno , the read index of the directory object will be rewinded.
+
+
Sample Code
+
+FRESULT scan_files (char* path)
+{
+ FRESULT res;
+ FILINFO fno;
+ DIR dir;
+ int i;
+
+
+ res = pf_opendir(&dir, path);
+ if (res == FR_OK) {
+ i = strlen(path);
+ for (;;) {
+ res = pf_readdir(&dir, &fno);
+ if (res != FR_OK || fno.fname[0] == 0) break;
+ if (fno.fattrib & AM_DIR) {
+ sprintf(&path[i], "/%s", fno.fname);
+ res = scan_files(path);
+ if (res != FR_OK) break;
+ path[i] = 0;
+ } else {
+ printf("%s/%s\n", path, fno.fname);
+ }
+ }
+ }
+
+ return res;
+}
+
+
+
QuickInfo
+
Available when _USE_DIR == 1 .
+
Petit FatFs - DIR
+
+
+
+
+
+
DIR
+
The DIR structure is used for the work area to read a directory by pf_oepndir, pf_readdir function.
+
+typedef struct {
+ WORD index; /* Current read/write index number */
+ BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+ CLUST sclust; /* Table start cluster (0:Static table) */
+ CLUST clust; /* Current cluster */
+ DWORD sect; /* Current sector */
+} DIR;
+
+
Petit FatFs - FATFS
+
+
+
+
+
+
FATFS
+
The FATFS structure holds dynamic work area of the logical drive and a file. It is given by application program and registerd/unregisterd to the Petit FatFs module with pf_mount function. There is no member that can be changed by application programs.
+
+typedef struct {
+ BYTE fs_type; /* FAT sub type */
+ BYTE csize; /* Number of sectors per cluster */
+ BYTE flag; /* File status flags */
+ BYTE pad1;
+ WORD n_rootdir; /* Number of root directory entries (0 on FAT32) */
+ CLUST n_fatent; /* Number of FAT entries (= number of clusters + 2) */
+ DWORD fatbase; /* FAT start sector */
+ DWORD dirbase; /* Root directory start sector (Cluster# on FAT32) */
+ DWORD database; /* Data start sector */
+ DWORD fptr; /* File read/write pointer */
+ DWORD fsize; /* File size */
+ CLUST org_clust; /* File start cluster */
+ CLUST curr_clust; /* File current cluster */
+ DWORD dsect; /* File current data sector */
+} FATFS;
+
+
Petit FatFs - FILINFO
+
+
+
+
+
+
FILINFO
+
The FILINFO structure holds a file information returned by pf_readdir function.
+
+typedef struct {
+ DWORD fsize; /* File size */
+ WORD fdate; /* Last modified date */
+ WORD ftime; /* Last modified time */
+ BYTE fattrib; /* Attribute */
+ char fname[13]; /* File name */
+} FILINFO;
+
+
Members
+
+fsize
+Indicates size of the file in unit of byte. This is always zero when it is a directory.
+fdate
+Indicates the date that the file was modified or the directory was created.
+bit15:9
+Year origin from 1980 (0..127)
+bit8:5
+Month (1..12)
+bit4:0
+Day (1..31)
+
+
+ftime
+Indicates the time that the file was modified or the directory was created.
+bit15:11
+Hour (0..23)
+bit10:5
+Minute (0..59)
+bit4:0
+Second / 2 (0..29)
+
+
+fattrib
+Indicates the file/directory attribute in combination of AM_DIR , AM_RDO , AM_HID , AM_SYS and AM_ARC .
+fname[]
+Indicates the file/directory name in 8.3 format null-terminated string.
+
+
+
+
+
diff --git a/3rdparty/petitfs-0.03/doc/pf/write.html b/3rdparty/petitfs-0.03/doc/pf/write.html
new file mode 100644
index 00000000..573a298b
--- /dev/null
+++ b/3rdparty/petitfs-0.03/doc/pf/write.html
@@ -0,0 +1,86 @@
+
+
+
+Petit FatFs - pf_write
+
+
+
+
+
+
pf_write
+
The pf_write function writes data to the file.
+
+FRESULT pf_write (
+ const void* buff , /* [IN] Pointer to the data to be written */
+ UINT btw , /* [IN] Number of bytes to write */
+ UINT* bw /* [OUT] Pointer to the variable to return number of bytes written */
+);
+
+
+
Parameters
+
+buff
+Pointer to the data to be wtitten. A NULL specifies to finalize the current write operation.
+btw
+Number of bytes to write.
+bw
+Pointer to the variable to return number of bytes read.
+
+
+
Return Values
+
+FR_OK (0)
+The function succeeded.
+FR_DISK_ERR
+The function failed due to a hard error in the disk function, write protected, a wrong FAT structure or an internal error.
+FR_NOT_OPENED
+The file has not been opened.
+FR_NOT_ENABLED
+The volume has not been mounted.
+
+
+
Description
+
The write function has some restrictions listed below:
+
+Cannot create file. Only existing file can be written.
+Cannot expand file size.
+Cannot update time stamp of the file.
+Write operation can start/stop on the sector boundary.
+Read-only attribute of the file cannot block write operation.
+
+
File write operation must be done in following sequence.
+
+pf_lseek(ofs); read/write pointer must be moved to sector bundary prior to initiate write operation or it will be rounded-down to the sector boundary.pf_write(buff, btw, &bw); Initiate write operation. Write first data to the file.pf_write(buff, btw, &bw); Write next data. Any other file function cannot be used while a write operation is in progress.pf_write(0, 0, &bw); Finalize the write operation. If read/write pointer is not on the sector boundary, left bytes in the sector will be filled with zero.
+
The read/write pointer in the file system object advances in number of bytes written. After the function succeeded, *bw should be checked to detect end of file. In case of *bw < btw , it means the read/write pointer reached end of file during the write operation. Once a write operation is initiated, it must be finalized or the written data can be lost.
+
+
QuickInfo
+
Available when _USE_WRITE == 1 .
+
+#include
+
+#else /* Embedded platform */
+
+/* This type MUST be 8 bit */
+typedef unsigned char BYTE;
+
+/* These types MUST be 16 bit */
+typedef short SHORT;
+typedef unsigned short WORD;
+typedef unsigned short WCHAR;
+
+/* These types MUST be 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 --git a/3rdparty/petitfs-0.03/src/pff.c b/3rdparty/petitfs-0.03/src/pff.c
new file mode 100644
index 00000000..674a9175
--- /dev/null
+++ b/3rdparty/petitfs-0.03/src/pff.c
@@ -0,0 +1,1108 @@
+/*----------------------------------------------------------------------------/
+/ Petit FatFs - FAT file system module R0.03 (C)ChaN, 2014
+/-----------------------------------------------------------------------------/
+/ Petit 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 trems.
+/
+/ Copyright (C) 2014, ChaN, all right reserved.
+/
+/ * The Petit 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.
+/
+/-----------------------------------------------------------------------------/
+/ Jun 15,'09 R0.01a First release.
+/
+/ Dec 14,'09 R0.02 Added multiple code page support.
+/ Added write funciton.
+/ Changed stream read mode interface.
+/ Dec 07,'10 R0.02a Added some configuration options.
+/ Fixed fails to open objects with DBCS character.
+
+/ Jun 10,'14 R0.03 Separated out configuration options to pffconf.h.
+/ Added _USE_LCC option.
+/ Added _FS_FAT16 option.
+/----------------------------------------------------------------------------*/
+
+#include "pff.h" /* Petit FatFs configurations and declarations */
+#include "diskio.h" /* Declarations of low level disk I/O functions */
+
+
+
+/*--------------------------------------------------------------------------
+
+ Module Private Definitions
+
+---------------------------------------------------------------------------*/
+
+
+#if _PFATFS != 4004 /* Revision ID */
+#error Wrong include file (pff.h).
+#endif
+
+#if _FS_FAT32
+#if !_FS_FAT16 && !_FS_FAT12
+#define _FS_32ONLY 1
+#else
+#define _FS_32ONLY 0
+#endif
+#else
+#if !_FS_FAT16 && !_FS_FAT12
+#error Wrong _FS_FATxx setting.
+#endif
+#define _FS_32ONLY 0
+#endif
+
+#define ABORT(err) {fs->flag = 0; return err;}
+
+
+
+/*--------------------------------------------------------*/
+/* 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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1250 /* Central Europe (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xA3,0xB4,0xB5,0xB6,0xB7,0xB8,0xA5,0xAA,0xBB,0xBC,0xBD,0xBC,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1251 /* Cyrillic (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x82,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x80,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x8D,0x8E,0x8F, \
+ 0xA0,0xA2,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB2,0xA5,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xA3,0xBD,0xBD,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF}
+
+#elif _CODE_PAGE == 1252 /* Latin 1 (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xAd,0x9B,0x8C,0x9D,0xAE,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1253 /* Greek (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xA2,0xB8,0xB9,0xBA, \
+ 0xE0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xF2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xBC,0xFD,0xBF,0xFF}
+
+#elif _CODE_PAGE == 1254 /* Turkish (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x8A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x9F}
+
+#elif _CODE_PAGE == 1255 /* Hebrew (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0x21,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1256 /* Arabic (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x8C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0x41,0xE1,0x41,0xE3,0xE4,0xE5,0xE6,0x43,0x45,0x45,0x45,0x45,0xEC,0xED,0x49,0x49,0xF0,0xF1,0xF2,0xF3,0x4F,0xF5,0xF6,0xF7,0xF8,0x55,0xFA,0x55,0x55,0xFD,0xFE,0xFF}
+
+#elif _CODE_PAGE == 1257 /* Baltic (Windows) */
+#define _EXCVT {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xA8,0xB9,0xAA,0xBB,0xBC,0xBD,0xBE,0xAF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xF7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xFF}
+
+#elif _CODE_PAGE == 1258 /* Vietnam (OEM, Windows) */
+#define _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}
+
+#else
+#error Unknown code page.
+
+#endif
+
+
+
+/* Character code support macros */
+
+#define IsUpper(c) (((c)>='A')&&((c)<='Z'))
+#define IsLower(c) (((c)>='a')&&((c)<='z'))
+
+#ifndef _EXCVT /* DBCS configuration */
+
+#ifdef _DF2S /* Two 1st byte areas */
+#define IsDBCS1(c) (((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#else /* One 1st byte area */
+#define IsDBCS1(c) ((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
+#endif
+
+#ifdef _DS3S /* Three 2nd byte areas */
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#else /* Two 2nd byte areas */
+#define IsDBCS2(c) (((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#endif
+
+#else /* SBCS configuration */
+
+#define IsDBCS1(c) 0
+#define IsDBCS2(c) 0
+
+#endif /* _EXCVT */
+
+
+/* FatFs refers the members in the FAT structures with byte offset instead
+/ of structure member because there are incompatibility of the packing option
+/ between various compilers. */
+
+#define BS_jmpBoot 0
+#define BS_OEMName 3
+#define BPB_BytsPerSec 11
+#define BPB_SecPerClus 13
+#define BPB_RsvdSecCnt 14
+#define BPB_NumFATs 16
+#define BPB_RootEntCnt 17
+#define BPB_TotSec16 19
+#define BPB_Media 21
+#define BPB_FATSz16 22
+#define BPB_SecPerTrk 24
+#define BPB_NumHeads 26
+#define BPB_HiddSec 28
+#define BPB_TotSec32 32
+#define BS_55AA 510
+
+#define BS_DrvNum 36
+#define BS_BootSig 38
+#define BS_VolID 39
+#define BS_VolLab 43
+#define BS_FilSysType 54
+
+#define BPB_FATSz32 36
+#define BPB_ExtFlags 40
+#define BPB_FSVer 42
+#define BPB_RootClus 44
+#define BPB_FSInfo 48
+#define BPB_BkBootSec 50
+#define BS_DrvNum32 64
+#define BS_BootSig32 66
+#define BS_VolID32 67
+#define BS_VolLab32 71
+#define BS_FilSysType32 82
+
+#define MBR_Table 446
+
+#define DIR_Name 0
+#define DIR_Attr 11
+#define DIR_NTres 12
+#define DIR_CrtTime 14
+#define DIR_CrtDate 16
+#define DIR_FstClusHI 20
+#define DIR_WrtTime 22
+#define DIR_WrtDate 24
+#define DIR_FstClusLO 26
+#define DIR_FileSize 28
+
+
+
+/*--------------------------------------------------------------------------
+
+ Private Functions
+
+---------------------------------------------------------------------------*/
+
+
+static
+FATFS *FatFs; /* Pointer to the file system object (logical drive) */
+
+
+/* Fill memory */
+static
+void mem_set (void* dst, int val, int cnt) {
+ char *d = (char*)dst;
+ while (cnt--) *d++ = (char)val;
+}
+
+/* Compare memory to memory */
+static
+int mem_cmp (const void* dst, const void* src, int cnt) {
+ const char *d = (const char *)dst, *s = (const char *)src;
+ int r = 0;
+ while (cnt-- && (r = *d++ - *s++) == 0) ;
+ return r;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* FAT access - Read value of a FAT entry */
+/*-----------------------------------------------------------------------*/
+
+static
+CLUST get_fat ( /* 1:IO error, Else:Cluster status */
+ CLUST clst /* Cluster# to get the link information */
+)
+{
+ BYTE buf[4];
+ FATFS *fs = FatFs;
+
+ if (clst < 2 || clst >= fs->n_fatent) /* Range check */
+ return 1;
+
+ switch (fs->fs_type) {
+#if _FS_FAT12
+ case FS_FAT12 : {
+ UINT wc, bc, ofs;
+
+ bc = (UINT)clst; bc += bc / 2;
+ ofs = bc % 512; bc /= 512;
+ if (ofs != 511) {
+ if (disk_readp(buf, fs->fatbase + bc, ofs, 2)) break;
+ } else {
+ if (disk_readp(buf, fs->fatbase + bc, 511, 1)) break;
+ if (disk_readp(buf+1, fs->fatbase + bc + 1, 0, 1)) break;
+ }
+ wc = LD_WORD(buf);
+ return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
+ }
+#endif
+#if _FS_FAT16
+ case FS_FAT16 :
+ if (disk_readp(buf, fs->fatbase + clst / 256, ((UINT)clst % 256) * 2, 2)) break;
+ return LD_WORD(buf);
+#endif
+#if _FS_FAT32
+ case FS_FAT32 :
+ if (disk_readp(buf, fs->fatbase + clst / 128, ((UINT)clst % 128) * 4, 4)) break;
+ return LD_DWORD(buf) & 0x0FFFFFFF;
+#endif
+ }
+
+ return 1; /* An error occured at the disk I/O layer */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get sector# from cluster# / Get cluster field from directory entry */
+/*-----------------------------------------------------------------------*/
+
+static
+DWORD clust2sect ( /* !=0: Sector number, 0: Failed - invalid cluster# */
+ CLUST clst /* Cluster# to be converted */
+)
+{
+ FATFS *fs = FatFs;
+
+
+ clst -= 2;
+ if (clst >= (fs->n_fatent - 2)) return 0; /* Invalid cluster# */
+ return (DWORD)clst * fs->csize + fs->database;
+}
+
+
+static
+CLUST get_clust (
+ BYTE* dir /* Pointer to directory entry */
+)
+{
+ FATFS *fs = FatFs;
+ CLUST clst = 0;
+
+
+ if (_FS_32ONLY || (_FS_FAT32 && fs->fs_type == FS_FAT32)) {
+ clst = LD_WORD(dir+DIR_FstClusHI);
+ clst <<= 16;
+ }
+ clst |= LD_WORD(dir+DIR_FstClusLO);
+
+ return clst;
+}
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Rewind directory index */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_rewind (
+ DIR *dj /* Pointer to directory object */
+)
+{
+ CLUST clst;
+ FATFS *fs = FatFs;
+
+
+ dj->index = 0;
+ clst = dj->sclust;
+ if (clst == 1 || clst >= fs->n_fatent) /* Check start cluster range */
+ return FR_DISK_ERR;
+ if (_FS_FAT32 && !clst && (_FS_32ONLY || fs->fs_type == FS_FAT32)) /* Replace cluster# 0 with root cluster# if in FAT32 */
+ clst = (CLUST)fs->dirbase;
+ dj->clust = clst; /* Current cluster */
+ dj->sect = (_FS_32ONLY || clst) ? clust2sect(clst) : fs->dirbase; /* Current sector */
+
+ return FR_OK; /* Seek succeeded */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Move directory index next */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_next ( /* FR_OK:Succeeded, FR_NO_FILE:End of table */
+ DIR *dj /* Pointer to directory object */
+)
+{
+ CLUST clst;
+ WORD i;
+ FATFS *fs = FatFs;
+
+
+ i = dj->index + 1;
+ if (!i || !dj->sect) /* Report EOT when index has reached 65535 */
+ return FR_NO_FILE;
+
+ if (!(i % 16)) { /* Sector changed? */
+ dj->sect++; /* Next sector */
+
+ if (dj->clust == 0) { /* Static table */
+ if (i >= fs->n_rootdir) /* Report EOT when end of table */
+ return FR_NO_FILE;
+ }
+ else { /* Dynamic table */
+ if (((i / 16) & (fs->csize - 1)) == 0) { /* Cluster changed? */
+ clst = get_fat(dj->clust); /* Get next cluster */
+ if (clst <= 1) return FR_DISK_ERR;
+ if (clst >= fs->n_fatent) /* When it reached end of dynamic table */
+ return FR_NO_FILE; /* Report EOT */
+ dj->clust = clst; /* Initialize data for new cluster */
+ dj->sect = clust2sect(clst);
+ }
+ }
+ }
+
+ dj->index = i;
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Directory handling - Find an object in the directory */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT dir_find (
+ DIR *dj, /* Pointer to the directory object linked to the file name */
+ BYTE *dir /* 32-byte working buffer */
+)
+{
+ FRESULT res;
+ BYTE c;
+
+
+ res = dir_rewind(dj); /* Rewind directory object */
+ if (res != FR_OK) return res;
+
+ do {
+ res = disk_readp(dir, dj->sect, (dj->index % 16) * 32, 32) /* Read an entry */
+ ? FR_DISK_ERR : FR_OK;
+ if (res != FR_OK) break;
+ c = dir[DIR_Name]; /* First character */
+ if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */
+ if (!(dir[DIR_Attr] & AM_VOL) && !mem_cmp(dir, dj->fn, 11)) /* Is it a valid entry? */
+ break;
+ res = dir_next(dj); /* Next entry */
+ } while (res == FR_OK);
+
+ return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read an object from the directory */
+/*-----------------------------------------------------------------------*/
+#if _USE_DIR
+static
+FRESULT dir_read (
+ DIR *dj, /* Pointer to the directory object to store read object name */
+ BYTE *dir /* 32-byte working buffer */
+)
+{
+ FRESULT res;
+ BYTE a, c;
+
+
+ res = FR_NO_FILE;
+ while (dj->sect) {
+ res = disk_readp(dir, dj->sect, (dj->index % 16) * 32, 32) /* Read an entry */
+ ? FR_DISK_ERR : FR_OK;
+ if (res != FR_OK) break;
+ c = dir[DIR_Name];
+ if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */
+ a = dir[DIR_Attr] & AM_MASK;
+ if (c != 0xE5 && c != '.' && !(a & AM_VOL)) /* Is it a valid entry? */
+ break;
+ res = dir_next(dj); /* Next entry */
+ if (res != FR_OK) break;
+ }
+
+ if (res != FR_OK) dj->sect = 0;
+
+ return res;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Pick a segment and create the object name in directory form */
+/*-----------------------------------------------------------------------*/
+
+
+static
+FRESULT create_name (
+ DIR *dj, /* Pointer to the directory object */
+ const char **path /* Pointer to pointer to the segment in the path string */
+)
+{
+ BYTE c, ni, si, i, *sfn;
+ const char *p;
+#if _USE_LCC
+#ifdef _EXCVT
+ static const BYTE cvt[] = _EXCVT;
+#endif
+#endif
+
+ /* Create file name in directory form */
+ sfn = dj->fn;
+ mem_set(sfn, ' ', 11);
+ si = i = 0; ni = 8;
+ p = *path;
+ for (;;) {
+ c = p[si++];
+ if (c <= ' ' || c == '/') break; /* Break on end of segment */
+ if (c == '.' || i >= ni) {
+ if (ni != 8 || c != '.') break;
+ i = 8; ni = 11;
+ continue;
+ }
+#if _USE_LCC
+#ifdef _EXCVT
+ if (c >= 0x80) /* To upper extended char (SBCS) */
+ c = cvt[c - 0x80];
+#endif
+ if (IsDBCS1(c) && i < ni - 1) { /* DBC 1st byte? */
+ BYTE d = p[si++]; /* Get 2nd byte */
+ sfn[i++] = c;
+ sfn[i++] = d;
+ } else
+#endif
+ { /* Single byte code */
+ if (_USE_LCC && IsLower(c)) c -= 0x20; /* toupper */
+ sfn[i++] = c;
+ }
+ }
+ *path = &p[si]; /* Rerurn pointer to the next segment */
+
+ sfn[11] = (c <= ' ') ? 1 : 0; /* Set last segment flag if end of path */
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get file information from directory entry */
+/*-----------------------------------------------------------------------*/
+#if _USE_DIR
+static
+void get_fileinfo ( /* No return code */
+ DIR *dj, /* Pointer to the directory object */
+ BYTE *dir, /* 32-byte working buffer */
+ FILINFO *fno /* Pointer to store the file information */
+)
+{
+ BYTE i, c;
+ char *p;
+
+
+ p = fno->fname;
+ if (dj->sect) {
+ for (i = 0; i < 8; i++) { /* Copy file name body */
+ c = dir[i];
+ if (c == ' ') break;
+ if (c == 0x05) c = 0xE5;
+ *p++ = c;
+ }
+ if (dir[8] != ' ') { /* Copy file name extension */
+ *p++ = '.';
+ for (i = 8; i < 11; i++) {
+ c = dir[i];
+ if (c == ' ') break;
+ *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;
+}
+#endif /* _USE_DIR */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Follow a file path */
+/*-----------------------------------------------------------------------*/
+
+static
+FRESULT follow_path ( /* FR_OK(0): successful, !=0: error code */
+ DIR *dj, /* Directory object to return last directory and found object */
+ BYTE *dir, /* 32-byte working buffer */
+ const char *path /* Full-path string to find a file or directory */
+)
+{
+ FRESULT res;
+
+
+ while (*path == ' ') path++; /* Strip leading spaces */
+ if (*path == '/') path++; /* Strip heading separator if exist */
+ dj->sclust = 0; /* Set start directory (always root dir) */
+
+ if ((BYTE)*path < ' ') { /* Null path means the root directory */
+ res = dir_rewind(dj);
+ dir[0] = 0;
+
+ } else { /* Follow path */
+ for (;;) {
+ res = create_name(dj, &path); /* Get a segment */
+ if (res != FR_OK) break;
+ res = dir_find(dj, dir); /* Find it */
+ if (res != FR_OK) break; /* Could not find the object */
+ if (dj->fn[11]) break; /* Last segment match. Function completed. */
+ if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow path because it is a file */
+ res = FR_NO_FILE; break;
+ }
+ dj->sclust = get_clust(dir); /* Follow next */
+ }
+ }
+
+ return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Check a sector if it is an FAT boot record */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE check_fs ( /* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record, 3:Error */
+ BYTE *buf, /* Working buffer */
+ DWORD sect /* Sector# (lba) to check if it is an FAT boot record or not */
+)
+{
+ if (disk_readp(buf, sect, 510, 2)) /* Read the boot record */
+ return 3;
+ if (LD_WORD(buf) != 0xAA55) /* Check record signature */
+ return 2;
+
+ if (!_FS_32ONLY && !disk_readp(buf, sect, BS_FilSysType, 2) && LD_WORD(buf) == 0x4146) /* Check FAT12/16 */
+ return 0;
+ if (_FS_FAT32 && !disk_readp(buf, sect, BS_FilSysType32, 2) && LD_WORD(buf) == 0x4146) /* Check FAT32 */
+ return 0;
+ return 1;
+}
+
+
+
+
+/*--------------------------------------------------------------------------
+
+ Public Functions
+
+--------------------------------------------------------------------------*/
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Mount/Unmount a Locical Drive */
+/*-----------------------------------------------------------------------*/
+
+FRESULT pf_mount (
+ FATFS *fs /* Pointer to new file system object */
+)
+{
+ BYTE fmt, buf[36];
+ DWORD bsect, fsize, tsect, mclst;
+
+
+ FatFs = 0;
+
+ if (disk_initialize() & STA_NOINIT) /* Check if the drive is ready or not */
+ return FR_NOT_READY;
+
+ /* Search FAT partition on the drive */
+ bsect = 0;
+ fmt = check_fs(buf, bsect); /* Check sector 0 as an SFD format */
+ if (fmt == 1) { /* Not an FAT boot record, it may be FDISK format */
+ /* Check a partition listed in top of the partition table */
+ if (disk_readp(buf, bsect, MBR_Table, 16)) { /* 1st partition entry */
+ fmt = 3;
+ } else {
+ if (buf[4]) { /* Is the partition existing? */
+ bsect = LD_DWORD(&buf[8]); /* Partition offset in LBA */
+ fmt = check_fs(buf, bsect); /* Check the partition */
+ }
+ }
+ }
+ if (fmt == 3) return FR_DISK_ERR;
+ if (fmt) return FR_NO_FILESYSTEM; /* No valid FAT patition is found */
+
+ /* Initialize the file system object */
+ if (disk_readp(buf, bsect, 13, sizeof (buf))) return FR_DISK_ERR;
+
+ fsize = LD_WORD(buf+BPB_FATSz16-13); /* Number of sectors per FAT */
+ if (!fsize) fsize = LD_DWORD(buf+BPB_FATSz32-13);
+
+ fsize *= buf[BPB_NumFATs-13]; /* Number of sectors in FAT area */
+ fs->fatbase = bsect + LD_WORD(buf+BPB_RsvdSecCnt-13); /* FAT start sector (lba) */
+ fs->csize = buf[BPB_SecPerClus-13]; /* Number of sectors per cluster */
+ fs->n_rootdir = LD_WORD(buf+BPB_RootEntCnt-13); /* Nmuber of root directory entries */
+ tsect = LD_WORD(buf+BPB_TotSec16-13); /* Number of sectors on the file system */
+ if (!tsect) tsect = LD_DWORD(buf+BPB_TotSec32-13);
+ mclst = (tsect /* Last cluster# + 1 */
+ - LD_WORD(buf+BPB_RsvdSecCnt-13) - fsize - fs->n_rootdir / 16
+ ) / fs->csize + 2;
+ fs->n_fatent = (CLUST)mclst;
+
+ fmt = 0; /* Determine the FAT sub type */
+ if (_FS_FAT12 && mclst < 0xFF7)
+ fmt = FS_FAT12;
+ if (_FS_FAT16 && mclst >= 0xFF8 && mclst < 0xFFF7)
+ fmt = FS_FAT16;
+ if (_FS_FAT32 && mclst >= 0xFFF7)
+ fmt = FS_FAT32;
+ if (!fmt) return FR_NO_FILESYSTEM;
+ fs->fs_type = fmt;
+
+ if (_FS_32ONLY || (_FS_FAT32 && fmt == FS_FAT32))
+ fs->dirbase = LD_DWORD(buf+(BPB_RootClus-13)); /* Root directory start cluster */
+ else
+ fs->dirbase = fs->fatbase + fsize; /* Root directory start sector (lba) */
+ fs->database = fs->fatbase + fsize + fs->n_rootdir / 16; /* Data start sector (lba) */
+
+ fs->flag = 0;
+ FatFs = fs;
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Open or Create a File */
+/*-----------------------------------------------------------------------*/
+
+FRESULT pf_open (
+ const char *path /* Pointer to the file name */
+)
+{
+ FRESULT res;
+ DIR dj;
+ BYTE sp[12], dir[32];
+ FATFS *fs = FatFs;
+
+
+ if (!fs) return FR_NOT_ENABLED; /* Check file system */
+
+ fs->flag = 0;
+ dj.fn = sp;
+ res = follow_path(&dj, dir, path); /* Follow the file path */
+ if (res != FR_OK) return res; /* Follow failed */
+ if (!dir[0] || (dir[DIR_Attr] & AM_DIR)) /* It is a directory */
+ return FR_NO_FILE;
+
+ fs->org_clust = get_clust(dir); /* File start cluster */
+ fs->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
+ fs->fptr = 0; /* File pointer */
+ fs->flag = FA_OPENED;
+
+ return FR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read File */
+/*-----------------------------------------------------------------------*/
+#if _USE_READ
+
+FRESULT pf_read (
+ void* buff, /* Pointer to the read buffer (NULL:Forward data to the stream)*/
+ UINT btr, /* Number of bytes to read */
+ UINT* br /* Pointer to number of bytes read */
+)
+{
+ DRESULT dr;
+ CLUST clst;
+ DWORD sect, remain;
+ UINT rcnt;
+ BYTE cs, *rbuff = buff;
+ FATFS *fs = FatFs;
+
+
+ *br = 0;
+ if (!fs) return FR_NOT_ENABLED; /* Check file system */
+ if (!(fs->flag & FA_OPENED)) /* Check if opened */
+ return FR_NOT_OPENED;
+
+ remain = fs->fsize - fs->fptr;
+ if (btr > remain) btr = (UINT)remain; /* Truncate btr by remaining bytes */
+
+ while (btr) { /* Repeat until all data transferred */
+ if ((fs->fptr % 512) == 0) { /* On the sector boundary? */
+ cs = (BYTE)(fs->fptr / 512 & (fs->csize - 1)); /* Sector offset in the cluster */
+ if (!cs) { /* On the cluster boundary? */
+ if (fs->fptr == 0) /* On the top of the file? */
+ clst = fs->org_clust;
+ else
+ clst = get_fat(fs->curr_clust);
+ if (clst <= 1) ABORT(FR_DISK_ERR);
+ fs->curr_clust = clst; /* Update current cluster */
+ }
+ sect = clust2sect(fs->curr_clust); /* Get current sector */
+ if (!sect) ABORT(FR_DISK_ERR);
+ fs->dsect = sect + cs;
+ }
+ rcnt = 512 - (UINT)fs->fptr % 512; /* Get partial sector data from sector buffer */
+ if (rcnt > btr) rcnt = btr;
+ dr = disk_readp(!buff ? 0 : rbuff, fs->dsect, (UINT)fs->fptr % 512, rcnt);
+ if (dr) ABORT(FR_DISK_ERR);
+ fs->fptr += rcnt; rbuff += rcnt; /* Update pointers and counters */
+ btr -= rcnt; *br += rcnt;
+ }
+
+ return FR_OK;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write File */
+/*-----------------------------------------------------------------------*/
+#if _USE_WRITE
+
+FRESULT pf_write (
+ const void* buff, /* Pointer to the data to be written */
+ UINT btw, /* Number of bytes to write (0:Finalize the current write operation) */
+ UINT* bw /* Pointer to number of bytes written */
+)
+{
+ CLUST clst;
+ DWORD sect, remain;
+ const BYTE *p = buff;
+ BYTE cs;
+ UINT wcnt;
+ FATFS *fs = FatFs;
+
+
+ *bw = 0;
+ if (!fs) return FR_NOT_ENABLED; /* Check file system */
+ if (!(fs->flag & FA_OPENED)) /* Check if opened */
+ return FR_NOT_OPENED;
+
+ if (!btw) { /* Finalize request */
+ if ((fs->flag & FA__WIP) && disk_writep(0, 0)) ABORT(FR_DISK_ERR);
+ fs->flag &= ~FA__WIP;
+ return FR_OK;
+ } else { /* Write data request */
+ if (!(fs->flag & FA__WIP)) /* Round-down fptr to the sector boundary */
+ fs->fptr &= 0xFFFFFE00;
+ }
+ remain = fs->fsize - fs->fptr;
+ if (btw > remain) btw = (UINT)remain; /* Truncate btw by remaining bytes */
+
+ while (btw) { /* Repeat until all data transferred */
+ if ((UINT)fs->fptr % 512 == 0) { /* On the sector boundary? */
+ cs = (BYTE)(fs->fptr / 512 & (fs->csize - 1)); /* Sector offset in the cluster */
+ if (!cs) { /* On the cluster boundary? */
+ if (fs->fptr == 0) /* On the top of the file? */
+ clst = fs->org_clust;
+ else
+ clst = get_fat(fs->curr_clust);
+ if (clst <= 1) ABORT(FR_DISK_ERR);
+ fs->curr_clust = clst; /* Update current cluster */
+ }
+ sect = clust2sect(fs->curr_clust); /* Get current sector */
+ if (!sect) ABORT(FR_DISK_ERR);
+ fs->dsect = sect + cs;
+ if (disk_writep(0, fs->dsect)) ABORT(FR_DISK_ERR); /* Initiate a sector write operation */
+ fs->flag |= FA__WIP;
+ }
+ wcnt = 512 - (UINT)fs->fptr % 512; /* Number of bytes to write to the sector */
+ if (wcnt > btw) wcnt = btw;
+ if (disk_writep(p, wcnt)) ABORT(FR_DISK_ERR); /* Send data to the sector */
+ fs->fptr += wcnt; p += wcnt; /* Update pointers and counters */
+ btw -= wcnt; *bw += wcnt;
+ if ((UINT)fs->fptr % 512 == 0) {
+ if (disk_writep(0, 0)) ABORT(FR_DISK_ERR); /* Finalize the currtent secter write operation */
+ fs->flag &= ~FA__WIP;
+ }
+ }
+
+ return FR_OK;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Seek File R/W Pointer */
+/*-----------------------------------------------------------------------*/
+#if _USE_LSEEK
+
+FRESULT pf_lseek (
+ DWORD ofs /* File pointer from top of file */
+)
+{
+ CLUST clst;
+ DWORD bcs, sect, ifptr;
+ FATFS *fs = FatFs;
+
+
+ if (!fs) return FR_NOT_ENABLED; /* Check file system */
+ if (!(fs->flag & FA_OPENED)) /* Check if opened */
+ return FR_NOT_OPENED;
+
+ if (ofs > fs->fsize) ofs = fs->fsize; /* Clip offset with the file size */
+ ifptr = fs->fptr;
+ fs->fptr = 0;
+ if (ofs > 0) {
+ bcs = (DWORD)fs->csize * 512; /* Cluster size (byte) */
+ if (ifptr > 0 &&
+ (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
+ fs->fptr = (ifptr - 1) & ~(bcs - 1); /* start from the current cluster */
+ ofs -= fs->fptr;
+ clst = fs->curr_clust;
+ } else { /* When seek to back cluster, */
+ clst = fs->org_clust; /* start from the first cluster */
+ fs->curr_clust = clst;
+ }
+ while (ofs > bcs) { /* Cluster following loop */
+ clst = get_fat(clst); /* Follow cluster chain */
+ if (clst <= 1 || clst >= fs->n_fatent) ABORT(FR_DISK_ERR);
+ fs->curr_clust = clst;
+ fs->fptr += bcs;
+ ofs -= bcs;
+ }
+ fs->fptr += ofs;
+ sect = clust2sect(clst); /* Current sector */
+ if (!sect) ABORT(FR_DISK_ERR);
+ fs->dsect = sect + (fs->fptr / 512 & (fs->csize - 1));
+ }
+
+ return FR_OK;
+}
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create a Directroy Object */
+/*-----------------------------------------------------------------------*/
+#if _USE_DIR
+
+FRESULT pf_opendir (
+ DIR *dj, /* Pointer to directory object to create */
+ const char *path /* Pointer to the directory path */
+)
+{
+ FRESULT res;
+ BYTE sp[12], dir[32];
+ FATFS *fs = FatFs;
+
+
+ if (!fs) { /* Check file system */
+ res = FR_NOT_ENABLED;
+ } else {
+ dj->fn = sp;
+ res = follow_path(dj, dir, path); /* Follow the path to the directory */
+ if (res == FR_OK) { /* Follow completed */
+ if (dir[0]) { /* It is not the root dir */
+ if (dir[DIR_Attr] & AM_DIR) /* The object is a directory */
+ dj->sclust = get_clust(dir);
+ else /* The object is not a directory */
+ res = FR_NO_FILE;
+ }
+ if (res == FR_OK)
+ res = dir_rewind(dj); /* Rewind dir */
+ }
+ }
+
+ return res;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Directory Entry in Sequense */
+/*-----------------------------------------------------------------------*/
+
+FRESULT pf_readdir (
+ DIR *dj, /* Pointer to the open directory object */
+ FILINFO *fno /* Pointer to file information to return */
+)
+{
+ FRESULT res;
+ BYTE sp[12], dir[32];
+ FATFS *fs = FatFs;
+
+
+ if (!fs) { /* Check file system */
+ res = FR_NOT_ENABLED;
+ } else {
+ dj->fn = sp;
+ if (!fno) {
+ res = dir_rewind(dj);
+ } else {
+ res = dir_read(dj, dir); /* Get current directory item */
+ if (res == FR_NO_FILE) res = FR_OK;
+ if (res == FR_OK) { /* A valid entry is found */
+ get_fileinfo(dj, dir, fno); /* Get the object information */
+ res = dir_next(dj); /* Increment read index for next */
+ if (res == FR_NO_FILE) res = FR_OK;
+ }
+ }
+ }
+
+ return res;
+}
+
+#endif /* _USE_DIR */
+
diff --git a/3rdparty/petitfs-0.03/src/pff.h b/3rdparty/petitfs-0.03/src/pff.h
new file mode 100644
index 00000000..4b55be40
--- /dev/null
+++ b/3rdparty/petitfs-0.03/src/pff.h
@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------/
+/ Petit FatFs - FAT file system module include file R0.03 (C)ChaN, 2014
+/----------------------------------------------------------------------------/
+/ Petit FatFs module is an open source software to implement FAT file system to
+/ small embedded systems. This is a free software and is opened for education,
+/ research and commercial developments under license policy of following trems.
+/
+/ Copyright (C) 2014, ChaN, all right reserved.
+/
+/ * The Petit 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 use UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/----------------------------------------------------------------------------*/
+
+#ifndef _PFATFS
+#define _PFATFS 4004 /* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "integer.h"
+#include "pffconf.h"
+
+#if _PFATFS != _PFFCONF
+#error Wrong configuration file (pffconf.h).
+#endif
+
+#if _FS_FAT32
+#define CLUST DWORD
+#else
+#define CLUST WORD
+#endif
+
+
+/* File system object structure */
+
+typedef struct {
+ BYTE fs_type; /* FAT sub type */
+ BYTE flag; /* File status flags */
+ BYTE csize; /* Number of sectors per cluster */
+ BYTE pad1;
+ WORD n_rootdir; /* Number of root directory entries (0 on FAT32) */
+ CLUST n_fatent; /* Number of FAT entries (= number of clusters + 2) */
+ DWORD fatbase; /* FAT start sector */
+ DWORD dirbase; /* Root directory start sector (Cluster# on FAT32) */
+ DWORD database; /* Data start sector */
+ DWORD fptr; /* File R/W pointer */
+ DWORD fsize; /* File size */
+ CLUST org_clust; /* File start cluster */
+ CLUST curr_clust; /* File current cluster */
+ DWORD dsect; /* File current data sector */
+} FATFS;
+
+
+
+/* Directory object structure */
+
+typedef struct {
+ WORD index; /* Current read/write index number */
+ BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+ CLUST sclust; /* Table start cluster (0:Static table) */
+ CLUST clust; /* Current cluster */
+ DWORD sect; /* Current sector */
+} DIR;
+
+
+
+/* File status structure */
+
+typedef struct {
+ DWORD fsize; /* File size */
+ WORD fdate; /* Last modified date */
+ WORD ftime; /* Last modified time */
+ BYTE fattrib; /* Attribute */
+ char fname[13]; /* File name */
+} FILINFO;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+ FR_OK = 0, /* 0 */
+ FR_DISK_ERR, /* 1 */
+ FR_NOT_READY, /* 2 */
+ FR_NO_FILE, /* 3 */
+ FR_NOT_OPENED, /* 4 */
+ FR_NOT_ENABLED, /* 5 */
+ FR_NO_FILESYSTEM /* 6 */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* Petit FatFs module application interface */
+
+FRESULT pf_mount (FATFS* fs); /* Mount/Unmount a logical drive */
+FRESULT pf_open (const char* path); /* Open a file */
+FRESULT pf_read (void* buff, UINT btr, UINT* br); /* Read data from the open file */
+FRESULT pf_write (const void* buff, UINT btw, UINT* bw); /* Write data to the open file */
+FRESULT pf_lseek (DWORD ofs); /* Move file pointer of the open file */
+FRESULT pf_opendir (DIR* dj, const char* path); /* Open a directory */
+FRESULT pf_readdir (DIR* dj, FILINFO* fno); /* Read a directory item from the open directory */
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address */
+
+/* File status flag (FATFS.flag) */
+
+#define FA_OPENED 0x01
+#define FA_WPRT 0x02
+#define FA__WIP 0x40
+
+
+/* FAT sub type (FATFS.fs_type) */
+
+#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 */
+
+
+/*--------------------------------*/
+/* 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)
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _PFATFS */
diff --git a/3rdparty/petitfs-0.03/src/pffconf.h b/3rdparty/petitfs-0.03/src/pffconf.h
new file mode 100644
index 00000000..c09c9fdb
--- /dev/null
+++ b/3rdparty/petitfs-0.03/src/pffconf.h
@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------/
+/ Petit FatFs - Configuration file R0.03 (C)ChaN, 2014
+/---------------------------------------------------------------------------*/
+
+#ifndef _PFFCONF
+#define _PFFCONF 4004 /* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define _USE_READ 1 /* Enable pf_read() function */
+#define _USE_DIR 0 /* Enable pf_opendir() and pf_readdir() function */
+#define _USE_LSEEK 0 /* Enable pf_lseek() function */
+#define _USE_WRITE 0 /* Enable pf_write() function */
+
+#define _FS_FAT12 0 /* Enable FAT12 */
+#define _FS_FAT16 1 /* Enable FAT16 */
+#define _FS_FAT32 0 /* Enable FAT32 */
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define _USE_LCC 0 /* Allow lower case characters for path name */
+
+#define _CODE_PAGE 437
+/* The _CODE_PAGE specifies the code page to be used on the target system.
+/ SBCS code pages with _USE_LCC == 1 requiers a 128 byte of case conversion
+/ table. This might occupy RAM on some platforms, e.g. avr-gcc.
+/ When _USE_LCC == 0, _CODE_PAGE has no effect.
+/
+/ 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)
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#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 for ALL instructions.
+/ * Byte order on the memory is little-endian.
+/
+/ If it is the case, _WORD_ACCESS can also be set to 1 to improve performance and
+/ reduce code size. Following table shows an example of some processor types.
+/
+/ ARM7TDMI 0 ColdFire 0 V850E 0
+/ Cortex-M3 0 Z80 0/1 V850ES 0/1
+/ Cortex-M0 0 RX600(LE) 0/1 TLCS-870 0/1
+/ AVR 0/1 RX600(BE) 0 TLCS-900 0/1
+/ AVR32 0 RL78 0 R32C 0
+/ PIC18 0/1 SH-2 0 M16C 0/1
+/ PIC24 0 H8S 0 MSP430 0
+/ PIC32 0 H8/300H 0 x86 0/1
+*/
+
+#endif /* _PFFCONF */
diff --git a/docs/releases.txt b/docs/releases.txt
index 2908535e..8af1409b 100644
--- a/docs/releases.txt
+++ b/docs/releases.txt
@@ -24,6 +24,7 @@ FEATURE: Added optional transparency to container
FEATURE: Prevent mouse events going to obscured widgets
FEATURE: Add GFILE support for file lists
FEATURE: Add GFILE support for C strings as files
+FEATURE: Add GFILE support for PetitFS
*** Release 2.1 ***
diff --git a/pffconf.h b/pffconf.h
new file mode 100644
index 00000000..e06cf025
--- /dev/null
+++ b/pffconf.h
@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------/
+/ Petit FatFs - Configuration file R0.03 (C)ChaN, 2014
+/---------------------------------------------------------------------------*/
+
+#ifndef _PFFCONF
+#define _PFFCONF 4004 /* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define _USE_READ 1 /* Enable pf_read() function */
+#define _USE_DIR GFILE_NEED_FILELISTS /* Enable pf_opendir() and pf_readdir() function */
+#define _USE_LSEEK 1 /* Enable pf_lseek() function */
+#define _USE_WRITE 0 /* Enable pf_write() function */
+
+#define _FS_FAT12 0 /* Enable FAT12 */
+#define _FS_FAT16 1 /* Enable FAT16 */
+#define _FS_FAT32 1 /* Enable FAT32 */
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define _USE_LCC 0 /* Allow lower case characters for path name */
+
+#define _CODE_PAGE 437
+/* The _CODE_PAGE specifies the code page to be used on the target system.
+/ SBCS code pages with _USE_LCC == 1 requiers a 128 byte of case conversion
+/ table. This might occupy RAM on some platforms, e.g. avr-gcc.
+/ When _USE_LCC == 0, _CODE_PAGE has no effect.
+/
+/ 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)
+*/
+
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#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 for ALL instructions.
+/ * Byte order on the memory is little-endian.
+/
+/ If it is the case, _WORD_ACCESS can also be set to 1 to improve performance and
+/ reduce code size. Following table shows an example of some processor types.
+/
+/ ARM7TDMI 0 ColdFire 0 V850E 0
+/ Cortex-M3 0 Z80 0/1 V850ES 0/1
+/ Cortex-M0 0 RX600(LE) 0/1 TLCS-870 0/1
+/ AVR 0/1 RX600(BE) 0 TLCS-900 0/1
+/ AVR32 0 RL78 0 R32C 0
+/ PIC18 0/1 SH-2 0 M16C 0/1
+/ PIC24 0 H8S 0 MSP430 0
+/ PIC32 0 H8/300H 0 x86 0/1
+*/
+
+#endif /* _PFFCONF */
diff --git a/src/gfile/inc_petitfs.c b/src/gfile/inc_petitfs.c
new file mode 100644
index 00000000..9b3b510b
--- /dev/null
+++ b/src/gfile/inc_petitfs.c
@@ -0,0 +1,157 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ * http://ugfx.org/license.html
+ */
+
+/********************************************************
+ * The PETITFS file-system
+ ********************************************************/
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_PETITFS
+
+#include "gfile_fs.h"
+#include "petitfs_wrapper.h"
+
+static bool_t petitfsExists(const char* fname);
+static bool_t petitfsOpen(GFILE* f, const char* fname);
+static int petitfsRead(GFILE* f, void* buf, int size);
+static bool_t petitfsSetPos(GFILE* f, long int pos);
+#if GFILE_NEED_FILELISTS && _FS_MINIMIZE <= 1
+ static gfileList *petitfsFlOpen(const char *path, bool_t dirs);
+ static const char *petitfsFlRead(gfileList *pfl);
+ static void petitfsFlClose(gfileList *pfl);
+#endif
+
+const GFILEVMT FsPetitFSVMT = {
+ GFSFLG_WRITEABLE | GFSFLG_SEEKABLE,
+ 'F',
+ 0,
+ petitfsExists,
+ 0, // No Filesize
+ 0,
+ petitfsOpen,
+ 0, // No Close
+ petitfsRead,
+ 0, // No Write
+ petitfsSetPos,
+ 0, // No Getsize
+ 0, // No EOF
+ 0, 0, 0, // No Mount, UnMount or Sync
+ #if GFILE_NEED_FILELISTS
+ #if _USE_DIR
+ petitfsFlOpen, petitfsFlRead, petitfsFlClose
+ #else
+ 0, 0, 0
+ #endif
+ #endif
+};
+
+// Our directory list structure
+typedef struct petitfsList {
+ gfileList fl; // This must be the first element.
+ DIR dir;
+ FILINFO fno;
+} petitfsList;
+
+// optimize these later on. Use an array to have multiple
+static bool_t petitfs_mounted = FALSE;
+static FATFS petitfs_fs;
+
+static bool_t petitfsExists(const char* fname)
+{
+ // Mount first
+ if (!petitfs_mounted && pf_mount(&petitfs_fs) != FR_OK)
+ return FALSE;
+
+ // Open
+ if (pf_open(fname) != FR_OK)
+ return FALSE;
+
+ return TRUE;
+}
+
+static bool_t petitfsOpen(GFILE* f, const char* fname)
+{
+ // No writing
+ if ((f->flags & GFILEFLG_WRITE))
+ return FALSE;
+
+ // Mount first
+ if (!petitfs_mounted && pf_mount(&petitfs_fs) != FR_OK)
+ return FALSE;
+
+ // Open
+ if (pf_open(fname) != FR_OK)
+ return FALSE;
+
+ f->obj = &petitfs_fs;
+ return TRUE;
+}
+
+static int petitfsRead(GFILE* f, void* buf, int size)
+{
+ int br;
+ (void) f;
+
+ if (pf_read(buf, size, (UINT*)&br) != FR_OK)
+ return 0;
+
+ return br;
+}
+
+static bool_t petitfsSetPos(GFILE* f, long int pos)
+{
+ (void) f;
+ return pf_lseek((DWORD)pos) == FR_OK;
+}
+
+#if GFILE_NEED_FILELISTS
+ static gfileList *petitfsFlOpen(const char *path, bool_t dirs) {
+ petitfsList *p;
+ (void) dirs;
+
+ if (!(p = gfxAlloc(sizeof(petitfsList))))
+ return 0;
+
+ if (pf_opendir(&p->dir, path) != FR_OK) {
+ gfxFree(p);
+ return 0;
+ }
+ return &p->fl;
+ }
+
+ static const char *petitfsFlRead(gfileList *pfl) {
+ #define ffl ((petitfsList *)pfl)
+
+ while(1) {
+ // Read the next entry
+ if (pf_readdir(&ffl->dir, &ffl->fno) != FR_OK || !ffl->fno.fname[0])
+ return 0;
+
+ /* Ignore dot entries */
+ if (ffl->fno.fname[0] == '.') continue;
+
+ /* Is it a directory */
+ if (ffl->fl.dirs) {
+ if ((ffl->fno.fattrib & AM_DIR))
+ break;
+ } else {
+ if (!(ffl->fno.fattrib & (AM_DIR|AM_HID|AM_SYS)))
+ break;
+ }
+ }
+
+ return ffl->fno.fname;
+ }
+
+ static void petitfsFlClose(gfileList *pfl) {
+ gfxFree(pfl);
+ }
+
+#endif
+
+#endif //GFX_USE_GFILE && GFILE_NEED_PETITFS
diff --git a/src/gfile/petitfs_chibios_diskio.c b/src/gfile/petitfs_chibios_diskio.c
new file mode 100644
index 00000000..dda3f6fc
--- /dev/null
+++ b/src/gfile/petitfs_chibios_diskio.c
@@ -0,0 +1,82 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2007 */
+/*-----------------------------------------------------------------------*/
+/* This is a stub disk I/O module that acts as front end of the existing */
+/* disk I/O modules and attach it to FatFs module with common interface. */
+/*-----------------------------------------------------------------------*/
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_PETITFS && GFX_USE_OS_CHIBIOS
+
+#include "petitfs_wrapper.h"
+
+#include
+
+#if HAL_USE_MMC_SPI && HAL_USE_SDC
+#error "cannot specify both MMC_SPI and SDC drivers"
+#endif
+
+#if HAL_USE_MMC_SPI
+extern MMCDriver MMCD1;
+#elif HAL_USE_SDC
+extern SDCDriver SDCD1;
+#else
+#error "MMC_SPI or SDC driver must be specified"
+#endif
+
+/*-----------------------------------------------------------------------*/
+/* Initialize a Drive */
+
+DSTATUS disk_initialize (void) {
+#if HAL_USE_MMC_SPI
+ /* It is initialized externally, just reads the status.*/
+ if (blkGetDriverState(&MMCD1) != BLK_READY)
+ return STA_NOINIT;
+#else
+ /* It is initialized externally, just reads the status.*/
+ if (blkGetDriverState(&SDCD1) != BLK_READY)
+ return STA_NOINIT;
+#endif
+ // All good
+ return 0;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Read Part Sector(s) */
+
+static BYTE sectBuf[512];
+static DWORD sectpos = -1;
+
+DRESULT disk_readp (
+ BYTE* buff, /* [OUT] Pointer to the read buffer */
+ DWORD sector, /* [IN] Sector number */
+ UINT offset, /* [IN] Byte offset in the sector to start to read */
+ UINT count /* [IN] Number of bytes to read */
+ ) {
+
+ if (sector != sectpos) {
+ #if HAL_USE_MMC_SPI
+ if (blkGetDriverState(&MMCD1) != BLK_READY)
+ return RES_NOTRDY;
+ if (mmcStartSequentialRead(&MMCD1, sector))
+ return RES_ERROR;
+ if (mmcSequentialRead(&MMCD1, sectBuf))
+ return RES_ERROR;
+ if (mmcStopSequentialRead(&MMCD1))
+ return RES_ERROR;
+ #else
+ if (blkGetDriverState(&SDCD1) != BLK_READY)
+ return RES_NOTRDY;
+ if (sdcRead(&SDCD1, sector, sectBuf, 1))
+ return RES_ERROR;
+ #endif
+ sectpos = sector;
+ }
+ memcpy(buff, sectBuf + offset, count);
+ return RES_OK;
+}
+
+#endif // GFX_USE_GFILE && GFILE_NEED_PETITFS && GFX_USE_OS_CHIBIOS
+
+
diff --git a/src/gfile/petitfs_wrapper.c b/src/gfile/petitfs_wrapper.c
new file mode 100644
index 00000000..183edb70
--- /dev/null
+++ b/src/gfile/petitfs_wrapper.c
@@ -0,0 +1,23 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ * http://ugfx.org/license.html
+ */
+
+/**
+ * @file src/gfile/petitfs_wrapper.c
+ * @brief GFILE PETITFS wrapper.
+ *
+ */
+
+#include "gfx.h"
+
+#if GFX_USE_GFILE && GFILE_NEED_PETITFS
+
+#include "petitfs_wrapper.h"
+
+// Include the source we want
+#include "3rdparty/petitfs-0.03/src/pff.c"
+
+#endif // GFX_USE_GFILE && GFILE_NEED_PETITFS
diff --git a/src/gfile/petitfs_wrapper.h b/src/gfile/petitfs_wrapper.h
new file mode 100644
index 00000000..4f91bd7f
--- /dev/null
+++ b/src/gfile/petitfs_wrapper.h
@@ -0,0 +1,26 @@
+/*
+ * This file is subject to the terms of the GFX License. If a copy of
+ * the license was not distributed with this file, you can obtain one at:
+ *
+ * http://ugfx.org/license.html
+ */
+
+/**
+ * @file src/gfile/petitfs_wrapper.h
+ * @brief GFILE PETITFS wrapper.
+ *
+ */
+
+#ifndef _PETITFS_WRAPPER
+#define _PETITFS_WRAPPER
+
+// Include the petitfs configuration from the local directory not the original source folder
+#include "pffconf.h"
+
+// Include the petitfs API
+#include "3rdparty/petitfs-0.03/src/pff.h"
+
+// Include the petitfs diskio API
+#include "3rdparty/petitfs-0.03/src/diskio.h"
+
+#endif //_PETITFS_WRAPPER
diff --git a/src/gfile/sys_make.mk b/src/gfile/sys_make.mk
index ba74a15c..e14527c6 100644
--- a/src/gfile/sys_make.mk
+++ b/src/gfile/sys_make.mk
@@ -3,6 +3,7 @@ GFXSRC += $(GFXLIB)/src/gfile/gfile.c \
$(GFXLIB)/src/gfile/inc_ramfs.c \
$(GFXLIB)/src/gfile/inc_romfs.c \
$(GFXLIB)/src/gfile/inc_fatfs.c \
+ $(GFXLIB)/src/gfile/inc_petitfs.c \
$(GFXLIB)/src/gfile/inc_memfs.c \
$(GFXLIB)/src/gfile/inc_chibiosfs.c \
$(GFXLIB)/src/gfile/inc_strings.c \
@@ -10,4 +11,8 @@ GFXSRC += $(GFXLIB)/src/gfile/gfile.c \
$(GFXLIB)/src/gfile/inc_scang.c \
$(GFXLIB)/src/gfile/inc_stdio.c \
$(GFXLIB)/src/gfile/fatfs_wrapper.c \
- $(GFXLIB)/src/gfile/fatfs_chibios_diskio.c
+ $(GFXLIB)/src/gfile/fatfs_chibios_diskio.c \
+ $(GFXLIB)/src/gfile/petitfs_wrapper.c \
+ $(GFXLIB)/src/gfile/petitfs_chibios_diskio.c \
+
+
\ No newline at end of file
diff --git a/src/gfile/sys_options.h b/src/gfile/sys_options.h
index ff1e5d4c..354d4f2b 100644
--- a/src/gfile/sys_options.h
+++ b/src/gfile/sys_options.h
@@ -101,16 +101,34 @@
#define GFILE_NEED_RAMFS FALSE
#endif
/**
- * @brief Include the FAT file system driver
+ * @brief Include the FAT file system driver based on the FATFS library
* @details Defaults to FALSE
* @note If GFILE_ALLOW_DEVICESPECIFIC is on then you can ensure that you are
* opening a file on the FAT file system by prefixing
* its name with "F|" (the letter 'F', followed by a vertical bar).
- * @note You must separately include the FATFS library and code.
+ * @note FATFS and PETITFS offer the same FAT file system support. They just use
+ * different constraints. PETITFS is smaller but has less features. Only
+ * one can be used at a time. The block interfaces are also different.
*/
#ifndef GFILE_NEED_FATFS
#define GFILE_NEED_FATFS FALSE
#endif
+ /**
+ * @brief Include the FAT file system driver based on the PETITFS library
+ * @details Defaults to FALSE
+ * @note If GFILE_ALLOW_DEVICESPECIFIC is on then you can ensure that you are
+ * opening a file on the FAT file system by prefixing
+ * its name with "F|" (the letter 'F', followed by a vertical bar).
+ * @note FATFS and PETITFS offer the same FAT file system support. They just use
+ * different constraints. PETITFS is smaller but has less features. Only
+ * one can be used at a time. The block interfaces are also different.
+ * @note Due to the restrictions on the PETITFS library on writing, we do not implement
+ * writing.
+ * @note PETITFS can only have one file open at a time.
+ */
+ #ifndef GFILE_NEED_PETITFS
+ #define GFILE_NEED_FATFS FALSE
+ #endif
/**
* @brief Include the operating system's native file system
* @details Defaults to FALSE
diff --git a/src/gfile/sys_rules.h b/src/gfile/sys_rules.h
index 8d07144d..d13041f2 100644
--- a/src/gfile/sys_rules.h
+++ b/src/gfile/sys_rules.h
@@ -17,6 +17,9 @@
#define _GFILE_RULES_H
#if GFX_USE_GFILE
+ #if GFILE_NEED_PETITFS && GFILE_NEED_FATFS
+ #error "GFILE: Both GFILE_NEED_PETITFS and GFILE_NEED_FATFS cannot both be turned on at the same time."
+ #endif
#endif
#endif /* _GFILE_RULES_H */
+
