[PATCH] fs: add fat filesystem support
Sascha Hauer
s.hauer at pengutronix.de
Mon Apr 11 10:23:09 EDT 2011
This code is based on:
http://elm-chan.org/fsw/ff/00index_e.html
FatFs Generic FAT File System Module
This patch offers a read/write implementation for barebox. The code
does not exaclty match barebox coding style, but works nicely and
should be ready to give it a try.
Signed-off-by: Sascha Hauer <s.hauer at pengutronix.de>
---
fs/Kconfig | 2 +
fs/Makefile | 1 +
fs/fat/Kconfig | 15 +
fs/fat/Makefile | 1 +
fs/fat/diskio.h | 78 ++
fs/fat/fat.c | 434 +++++++++
fs/fat/ff.c | 2761 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/fat/ff.h | 239 +++++
fs/fat/ffconf.h | 145 +++
fs/fat/integer.h | 28 +
10 files changed, 3704 insertions(+), 0 deletions(-)
create mode 100644 fs/fat/Kconfig
create mode 100644 fs/fat/Makefile
create mode 100644 fs/fat/diskio.h
create mode 100644 fs/fat/fat.c
create mode 100644 fs/fat/ff.c
create mode 100644 fs/fat/ff.h
create mode 100644 fs/fat/ffconf.h
create mode 100644 fs/fat/integer.h
diff --git a/fs/Kconfig b/fs/Kconfig
index d05797a..56c02da 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -16,6 +16,8 @@ config FS_DEVFS
default y
prompt "devfs support"
+source fs/fat/Kconfig
+
config PARTITION_NEED_MTD
bool
diff --git a/fs/Makefile b/fs/Makefile
index 4aa92ef..7cae2b6 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -2,4 +2,5 @@ obj-$(CONFIG_FS_CRAMFS) += cramfs/
obj-$(CONFIG_FS_RAMFS) += ramfs.o
obj-y += devfs-core.o
obj-$(CONFIG_FS_DEVFS) += devfs.o
+obj-$(CONFIG_FS_FAT) += fat/
obj-y += fs.o
diff --git a/fs/fat/Kconfig b/fs/fat/Kconfig
new file mode 100644
index 0000000..0699728
--- /dev/null
+++ b/fs/fat/Kconfig
@@ -0,0 +1,15 @@
+menuconfig FS_FAT
+ bool
+ prompt "FAT filesystem support"
+
+if FS_FAT
+
+config FS_FAT_WRITE
+ bool
+ prompt "FAT write support"
+
+config FS_FAT_LFN
+ bool
+ prompt "Support long filenames"
+
+endif
diff --git a/fs/fat/Makefile b/fs/fat/Makefile
new file mode 100644
index 0000000..efc89ec
--- /dev/null
+++ b/fs/fat/Makefile
@@ -0,0 +1 @@
+obj-y += ff.o fat.o
diff --git a/fs/fat/diskio.h b/fs/fat/diskio.h
new file mode 100644
index 0000000..f0d29dc
--- /dev/null
+++ b/fs/fat/diskio.h
@@ -0,0 +1,78 @@
+/*-----------------------------------------------------------------------
+/ Low level disk interface modlue include file
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO
+
+#define _READONLY 0 /* 1: Remove write functions */
+#define _USE_IOCTL 1 /* 1: Use disk_ioctl fucntion */
+
+#include "integer.h"
+
+
+/* Status of Disk Functions */
+typedef BYTE DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+ RES_OK = 0, /* 0: Successful */
+ RES_ERROR, /* 1: R/W Error */
+ RES_WRPRT, /* 2: Write Protected */
+ RES_NOTRDY, /* 3: Not Ready */
+ RES_PARERR /* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+int assign_drives (int, int);
+DSTATUS disk_initialize (FATFS *fatfs);
+DSTATUS disk_status (FATFS *fatfs);
+DRESULT disk_read (FATFS *fatfs, BYTE*, DWORD, BYTE);
+#if _READONLY == 0
+DRESULT disk_write (FATFS *fatfs, const BYTE*, DWORD, BYTE);
+#endif
+DRESULT disk_ioctl (FATFS *fatfs, BYTE, void*);
+
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT 0x01 /* Drive not initialized */
+#define STA_NODISK 0x02 /* No medium in the drive */
+#define STA_PROTECT 0x04 /* Write protected */
+
+
+/* Command code for disk_ioctrl fucntion */
+
+/* Generic command (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 */
+#define CTRL_POWER 5 /* Get/Set power status */
+#define CTRL_LOCK 6 /* Lock/Unlock media removal */
+#define CTRL_EJECT 7 /* Eject 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 */
+
+/* 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 */
+
+
+#define _DISKIO
+#endif
diff --git a/fs/fat/fat.c b/fs/fat/fat.c
new file mode 100644
index 0000000..4219801
--- /dev/null
+++ b/fs/fat/fat.c
@@ -0,0 +1,434 @@
+/*
+ * ramfs.c - a malloc based filesystem
+ *
+ * Copyright (c) 2007 Sascha Hauer <s.hauer at pengutronix.de>, Pengutronix
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <common.h>
+#include <driver.h>
+#include <init.h>
+#include <malloc.h>
+#include <fs.h>
+#include <command.h>
+#include <errno.h>
+#include <linux/stat.h>
+#include <linux/ctype.h>
+#include <xfuncs.h>
+#include <fcntl.h>
+#include "ff.h"
+#include "integer.h"
+#include "diskio.h"
+
+struct fat_priv {
+ struct cdev *cdev;
+ FATFS fat;
+};
+
+/* ---------------------------------------------------------------*/
+
+DRESULT disk_read(FATFS *fat, BYTE *buf, DWORD sector, BYTE count)
+{
+ struct fat_priv *priv = fat->userdata;
+ int ret;
+
+ debug("%s: sector: %ld count: %d\n", __func__, sector, count);
+
+ ret = cdev_read(priv->cdev, buf, count << 9, sector * 512, 0);
+ if (ret != count << 9)
+ return ret;
+
+ return 0;
+}
+
+DRESULT disk_write(FATFS *fat, const BYTE *buf, DWORD sector, BYTE count)
+{
+ struct fat_priv *priv = fat->userdata;
+ int ret;
+
+ debug("%s: buf: %p sector: %ld count: %d\n",
+ __func__, buf, sector, count);
+
+ ret = cdev_write(priv->cdev, buf, count << 9, sector * 512, 0);
+ if (ret != count << 9)
+ return ret;
+
+ return 0;
+}
+
+DSTATUS disk_status(FATFS *fat)
+{
+ return 0;
+}
+
+DWORD get_fattime(void)
+{
+ return 0;
+}
+
+DRESULT disk_ioctl (FATFS *fat, BYTE command, void *buf)
+{
+ return 0;
+}
+
+WCHAR ff_convert(WCHAR src, UINT dir)
+{
+ if (src <= 0x80)
+ return src;
+ else
+ return '?';
+}
+
+WCHAR ff_wtoupper(WCHAR chr)
+{
+ if (chr <= 0x80)
+ return toupper(chr);
+ else
+ return '?';
+}
+
+/* ---------------------------------------------------------------*/
+
+#ifdef CONFIG_FS_FAT_WRITE
+static int fat_create(struct device_d *dev, const char *pathname, mode_t mode)
+{
+ struct fat_priv *priv = dev->priv;
+ FIL f_file;
+ int ret;
+
+ ret = f_open(&priv->fat, &f_file, pathname, FA_OPEN_ALWAYS);
+ if (ret)
+ return -EINVAL;
+
+ f_close(&f_file);
+
+ return 0;
+}
+
+static int fat_unlink(struct device_d *dev, const char *pathname)
+{
+ struct fat_priv *priv = dev->priv;
+ int ret;
+
+ ret = f_unlink(&priv->fat, pathname);
+ if (ret)
+ return ret;
+
+ cdev_flush(priv->cdev);
+
+ return 0;
+}
+
+static int fat_mkdir(struct device_d *dev, const char *pathname)
+{
+ struct fat_priv *priv = dev->priv;
+ int ret;
+
+ ret = f_mkdir(&priv->fat, pathname);
+ if (ret)
+ return ret;
+
+ cdev_flush(priv->cdev);
+
+ return 0;
+}
+
+static int fat_rmdir(struct device_d *dev, const char *pathname)
+{
+ struct fat_priv *priv = dev->priv;
+ int ret;
+
+ ret = f_unlink(&priv->fat, pathname);
+ if (ret)
+ return ret;
+
+ cdev_flush(priv->cdev);
+
+ return 0;
+}
+
+static int fat_write(struct device_d *_dev, FILE *f, const void *buf, size_t insize)
+{
+ FIL *f_file = f->inode;
+ int outsize;
+ int ret;
+
+ ret = f_write(f_file, buf, insize, &outsize);
+
+ debug("%s: %d %d %d %p\n", __func__, ret, insize, outsize, f_file);
+
+ if (ret)
+ return ret;
+ if (!outsize)
+ return -ENOSPC;
+
+ return outsize;
+}
+
+static int fat_truncate(struct device_d *dev, FILE *f, ulong size)
+{
+ FIL *f_file = f->inode;
+ unsigned long lastofs;
+ int ret;
+
+ lastofs = f_file->fptr;
+
+ ret = f_lseek(f_file, size);
+ if (ret)
+ return ret;
+
+ ret = f_truncate(f_file);
+ if (ret)
+ return ret;
+
+ ret = f_lseek(f_file, lastofs);
+ if (ret)
+ return ret;
+
+ return 0;
+}
+#endif /* CONFIG_FS_FAT_WRITE */
+
+static int fat_open(struct device_d *dev, FILE *file, const char *filename)
+{
+ struct fat_priv *priv = dev->priv;
+ FIL *f_file;
+ int ret;
+ unsigned long flags = 0;
+
+ f_file = xzalloc(sizeof(*f_file));
+
+ switch (file->flags & O_ACCMODE) {
+ case O_RDONLY:
+ flags = FA_READ;
+ break;
+ case O_WRONLY:
+ flags = FA_WRITE;
+ break;
+ case O_RDWR:
+ flags = FA_READ | FA_WRITE;
+ break;
+ }
+
+ ret = f_open(&priv->fat, f_file, filename, flags);
+ if (ret) {
+ free(f_file);
+ return -EINVAL;
+ }
+
+ if (file->flags & O_APPEND) {
+ ret = f_lseek(f_file, f_file->fsize);
+ }
+
+ file->inode = f_file;
+ file->size = f_file->fsize;
+
+ return 0;
+}
+
+static int fat_close(struct device_d *dev, FILE *f)
+{
+ struct fat_priv *priv = dev->priv;
+ FIL *f_file = f->inode;
+
+ f_close(f_file);
+
+ free(f_file);
+
+ cdev_flush(priv->cdev);
+
+ return 0;
+}
+
+static int fat_read(struct device_d *_dev, FILE *f, void *buf, size_t insize)
+{
+ int ret;
+ FIL *f_file = f->inode;
+ int outsize;
+
+ ret = f_read(f_file, buf, insize, &outsize);
+
+ debug("%s: %d %d %d %p\n", __func__, ret, insize, outsize, f_file);
+
+ if (ret)
+ return ret;
+
+ return outsize;
+}
+
+static off_t fat_lseek(struct device_d *dev, FILE *f, off_t pos)
+{
+ FIL *f_file = f->inode;
+ int ret;
+
+ ret = f_lseek(f_file, pos);
+ if (ret)
+ return ret;
+
+ return pos;
+}
+
+static DIR* fat_opendir(struct device_d *dev, const char *pathname)
+{
+ struct fat_priv *priv = dev->priv;
+ DIR *dir;
+ FF_DIR *ff_dir;
+ int ret;
+
+ debug("%s: %s\n", __func__, pathname);
+
+ ff_dir = xzalloc(sizeof(*ff_dir));
+ if (pathname)
+ ret = f_opendir(&priv->fat, ff_dir, pathname);
+ else
+ ret = f_opendir(&priv->fat, ff_dir, "/");
+
+ if (ret)
+ return NULL;
+
+ dir = xzalloc(sizeof(*dir));
+
+ dir->priv = ff_dir;
+
+ return dir;
+}
+
+static struct dirent* fat_readdir(struct device_d *dev, DIR *dir)
+{
+ FF_DIR *ff_dir = dir->priv;
+ FILINFO finfo;
+ int ret;
+#ifdef CONFIG_FS_FAT_LFN
+ char name[PATH_MAX];
+#endif
+ memset(&finfo, 0, sizeof(finfo));
+#ifdef CONFIG_FS_FAT_LFN
+ finfo.lfname = name;
+ finfo.lfsize = PATH_MAX;
+#endif
+ ret = f_readdir(ff_dir, &finfo);
+ if (ret)
+ return NULL;
+
+ if (finfo.fname[0] == '\0')
+ return NULL;
+
+#ifdef CONFIG_FS_FAT_LFN
+ if (*finfo.lfname)
+ strcpy(dir->d.d_name, finfo.lfname);
+ else
+#endif
+ strcpy(dir->d.d_name, finfo.fname);
+
+ return &dir->d;
+}
+
+static int fat_closedir(struct device_d *dev, DIR *dir)
+{
+ FF_DIR *ff_dir = dir->priv;
+
+ free(ff_dir);
+ free(dir);
+
+ return 0;
+}
+
+static int fat_stat(struct device_d *dev, const char *filename, struct stat *s)
+{
+ struct fat_priv *priv = dev->priv;
+ FILINFO finfo;
+ int ret;
+
+ ret = f_stat(&priv->fat, filename, &finfo);
+ if (ret)
+ return ret;
+
+ s->st_size = finfo.fsize;
+ s->st_mode = S_IRWXU | S_IRWXG | S_IRWXO;
+
+ if (finfo.fattrib & AM_DIR)
+ s->st_mode |= S_IFDIR;
+ else
+ s->st_mode |= S_IFREG;
+
+ return 0;
+}
+
+static int fat_probe(struct device_d *dev)
+{
+ struct fs_device_d *fsdev = dev->type_data;
+ struct fat_priv *priv = xzalloc(sizeof(struct fat_priv));
+ char *backingstore = fsdev->backingstore;
+
+ dev->priv = priv;
+
+ if (!strncmp(backingstore , "/dev/", 5))
+ backingstore += 5;
+
+ priv->cdev = cdev_open(backingstore, O_RDWR);
+ if (!priv->cdev)
+ return -EINVAL;
+
+ priv->fat.userdata = priv;
+ f_mount(&priv->fat);
+
+ return 0;
+}
+
+static void fat_remove(struct device_d *dev)
+{
+ struct fat_priv *priv = dev->priv;
+
+ cdev_close(priv->cdev);
+
+ free(dev->priv);
+}
+
+static struct fs_driver_d fat_driver = {
+ .open = fat_open,
+ .close = fat_close,
+ .read = fat_read,
+ .lseek = fat_lseek,
+ .opendir = fat_opendir,
+ .readdir = fat_readdir,
+ .closedir = fat_closedir,
+ .stat = fat_stat,
+#ifdef CONFIG_FS_FAT_WRITE
+ .create = fat_create,
+ .unlink = fat_unlink,
+ .mkdir = fat_mkdir,
+ .rmdir = fat_rmdir,
+ .write = fat_write,
+ .truncate = fat_truncate,
+#endif
+ .flags = 0,
+ .drv = {
+ .probe = fat_probe,
+ .remove = fat_remove,
+ .name = "fat",
+ .type_data = &fat_driver,
+ }
+};
+
+static int fat_init(void)
+{
+ return register_fs_driver(&fat_driver);
+}
+
+coredevice_initcall(fat_init);
+
diff --git a/fs/fat/ff.c b/fs/fat/ff.c
new file mode 100644
index 0000000..bcd0a93
--- /dev/null
+++ b/fs/fat/ff.c
@@ -0,0 +1,2761 @@
+/*----------------------------------------------------------------------------/
+/ FatFs - FAT file system module R0.08b (C)ChaN, 2011
+/-----------------------------------------------------------------------------/
+/ 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) 2011, 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).
+/
+/ 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.
+/
+/ 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 0 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.
+/
+/ 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 names.
+/---------------------------------------------------------------------------*/
+
+#include <string.h>
+#include <errno.h>
+#include <malloc.h>
+#include <linux/ctype.h>
+#include "ff.h" /* FatFs configurations and declarations */
+#include "diskio.h" /* Declarations of low level disk I/O functions */
+
+#if _FATFS != 8237
+#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) /* Multiple sector size */
+#else
+#define SS(fs) 512U /* Fixed sector size */
+#endif
+
+#define ABORT(fs, res) { fp->flag |= FA__ERROR; return res; }
+
+/* Misc definitions */
+#define LD_CLUST(dir) (((DWORD)LD_WORD(dir+DIR_FstClusHI)<<16) | LD_WORD(dir+DIR_FstClusLO))
+#define ST_CLUST(dir,cl) {ST_WORD(dir+DIR_FstClusLO, cl); ST_WORD(dir+DIR_FstClusHI, (DWORD)cl>>16);}
+
+
+/* DBCS code ranges and SBCS extend char conversion table */
+
+/* Codepage 437 (US 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, \
+}
+
+#define IsDBCS1(c) 0
+#define IsDBCS2(c) 0
+
+/* 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 */
+
+
+/* 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 sectot (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_CrtTime 14 /* Created time (2) */
+#define DIR_CrtDate 16 /* Created 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 enrty mark in DIR_Name[0] */
+#define NDDE 0x05 /* Replacement of a character collides with DDE */
+
+#ifndef CONFIG_FS_FAT_LFN
+#define DEF_NAMEBUF BYTE sfn[12]
+#define INIT_BUF(dobj) (dobj).fn = sfn
+#define FREE_BUF()
+
+#else
+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()
+#endif
+
+/*
+ * Change window offset
+ */
+struct fat_sector {
+ DWORD sector;
+ struct list_head list;
+ unsigned char data[0];
+};
+
+#ifdef CONFIG_FS_FAT_WRITE
+static int push_fat_sector(FATFS *fs, DWORD sector)
+{
+ struct fat_sector *s;
+
+ list_for_each_entry(s, &fs->dirtylist, list) {
+ if (s->sector == sector) {
+ memcpy(s->data, fs->win, SS(fs));
+ return 0;
+ }
+ }
+
+ s = xmalloc(sizeof(*s) + SS(fs));
+ memcpy(s->data, fs->win, SS(fs));
+ s->sector = sector;
+ list_add_tail(&s->list, &fs->dirtylist);
+
+ return 0;
+}
+#endif
+
+static int get_fat_sector(FATFS *fs, DWORD sector)
+{
+ struct fat_sector *s;
+
+ list_for_each_entry(s, &fs->dirtylist, list) {
+ if (s->sector == sector) {
+ memcpy(fs->win, s->data, SS(fs));
+ return 0;
+ }
+ }
+
+ return disk_read(fs, fs->win, sector, 1);
+}
+
+#ifdef CONFIG_FS_FAT_WRITE
+static int flush_dirty_fat(FATFS *fs)
+{
+ struct fat_sector *s, *tmp;
+
+ list_for_each_entry_safe(s, tmp, &fs->dirtylist, list) {
+ disk_write(fs, s->data, s->sector, 1);
+ if (s->sector < (fs->fatbase + fs->fsize)) {
+ /* In FAT area */
+ BYTE nf;
+ DWORD wsect = s->sector;
+ /* Reflect the change to all FAT copies */
+ for (nf = fs->n_fats; nf > 1; nf--) {
+ wsect += fs->fsize;
+ disk_write(fs, s->data, wsect, 1);
+ }
+ }
+ list_del(&s->list);
+ free(s);
+ }
+
+ return 0;
+}
+#endif
+
+static int 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 */
+{
+ DWORD wsect;
+ int ret;
+
+ wsect = fs->winsect;
+ if (wsect != sector) { /* Changed current window */
+#ifdef CONFIG_FS_FAT_WRITE
+ /* Write back dirty window if needed */
+ if (fs->wflag) {
+ ret = push_fat_sector(fs, wsect);
+ if (ret)
+ return ret;
+ fs->wflag = 0;
+ }
+#endif
+ if (sector) {
+ ret = get_fat_sector(fs, sector);
+ if (ret)
+ return ret;
+ fs->winsect = sector;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Clean-up cached data
+ */
+#ifdef CONFIG_FS_FAT_WRITE
+static
+int sync ( /* 0: successful, -EIO: failed */
+ FATFS *fs /* File system object */
+)
+{
+ int res;
+
+ res = move_window(fs, 0);
+ if (res == 0) {
+ /* Update FSInfo sector if needed */
+ if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {
+ fs->winsect = 0;
+ /* Create FSInfo structure */
+ memset(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, 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, CTRL_SYNC, (void*)0) != RES_OK)
+ res = -EIO;
+ }
+
+ return res;
+}
+#endif
+
+/*
+ * Get sector# from cluster#
+ */
+DWORD clust2sect ( /* !=0: Sector number, 0: Failed - invalid cluster# */
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to be converted */
+)
+{
+ clst -= 2;
+ if (clst >= (fs->n_fatent - 2))
+ return 0; /* Invalid cluster */
+ return clst * fs->csize + fs->database;
+}
+
+/*
+ * FAT access - Read value of a FAT entry
+ */
+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 */
+)
+{
+ UINT wc, bc;
+ BYTE *p;
+
+
+ if (clst < 2 || clst >= fs->n_fatent) /* Chack 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 */
+}
+
+
+
+
+/*
+ * FAT access - Change value of a FAT entry
+ */
+#ifdef CONFIG_FS_FAT_WRITE
+
+int 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 */
+)
+{
+ UINT bc;
+ BYTE *p;
+ int res;
+
+
+ if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
+ res = -ERESTARTSYS;
+
+ } else {
+ switch (fs->fs_type) {
+ case FS_FAT12 :
+ bc = clst; bc += bc / 2;
+ res = move_window(fs, fs->fatbase + (bc / SS(fs)));
+ if (res != 0)
+ 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 != 0)
+ 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 != 0)
+ 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 != 0)
+ break;
+ p = &fs->win[clst * 4 % SS(fs)];
+ val |= LD_DWORD(p) & 0xF0000000;
+ ST_DWORD(p, val);
+ break;
+
+ default :
+ res = -ERESTARTSYS;
+ }
+ fs->wflag = 1;
+ }
+
+ return res;
+}
+#endif /* CONFIG_FS_FAT_WRITE */
+
+
+
+
+/*
+ * FAT handling - Remove a cluster chain
+ */
+#ifdef CONFIG_FS_FAT_WRITE
+static
+int remove_chain (
+ FATFS *fs, /* File system object */
+ DWORD clst /* Cluster# to remove a chain from */
+)
+{
+ int res;
+ DWORD nxt;
+#if _USE_ERASE
+ DWORD scl = clst, ecl = clst, resion[2];
+#endif
+
+ if (clst < 2 || clst >= fs->n_fatent) { /* Check range */
+ res = -ERESTARTSYS;
+
+ } else {
+ res = 0;
+ 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 = -ERESTARTSYS;
+ break; /* Internal error? */
+ }
+
+ if (nxt == 0xFFFFFFFF) {
+ res = -EIO;
+ break; /* Disk error? */
+ }
+
+ /* Mark the cluster "empty" */
+ res = put_fat(fs, clst, 0);
+ if (res != 0)
+ break;
+
+ if (fs->free_clust != 0xFFFFFFFF) { /* Update FSInfo */
+ fs->free_clust++;
+ fs->fsi_flag = 1;
+ }
+#if _USE_ERASE
+ if (ecl + 1 == nxt) { /* Next cluster is contiguous */
+ ecl = nxt;
+ } else {
+ /* End of contiguous clusters */
+ resion[0] = clust2sect(fs, scl); /* Start sector */
+ resion[1] = clust2sect(fs, ecl) + fs->csize - 1; /* End sector */
+ disk_ioctl(fs, CTRL_ERASE_SECTOR, resion); /* Erase the block */
+ scl = ecl = nxt;
+ }
+#endif
+ clst = nxt; /* Next cluster */
+ }
+ }
+
+ return res;
+}
+#endif
+
+
+
+
+/*
+ * FAT handling - Stretch or Create a cluster chain
+ */
+#ifdef CONFIG_FS_FAT_WRITE
+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 cs, ncl, scl;
+ int 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 */
+ }
+
+ /* Mark the new cluster "last link" */
+ res = put_fat(fs, ncl, 0x0FFFFFFF);
+ if (res == 0 && clst != 0) {
+ res = put_fat(fs, clst, ncl); /* Link it to the previous one if needed */
+ }
+ if (res == 0) {
+ /* Update FSINFO */
+ fs->last_clust = ncl;
+ if (fs->free_clust != 0xFFFFFFFF) {
+ fs->free_clust--;
+ fs->fsi_flag = 1;
+ }
+ } else {
+ ncl = (res == -EIO) ? 0xFFFFFFFF : 1;
+ }
+
+ return ncl; /* Return new cluster number or error code */
+}
+#endif /* CONFIG_FS_FAT_WRITE */
+
+/*
+ * Directory handling - Set directory index
+ */
+static int dir_sdi (
+ FF_DIR *dj, /* Pointer to directory object */
+ WORD idx /* Directory index number */
+)
+{
+ DWORD clst;
+ WORD ic;
+
+ dj->index = idx;
+ clst = dj->sclust;
+
+ if (clst == 1 || clst >= dj->fs->n_fatent) /* Check start cluster range */
+ return -ERESTARTSYS;
+
+ 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 -ERESTARTSYS;
+
+ 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 -EIO; /* Disk error */
+ if (clst < 2 || clst >= dj->fs->n_fatent)
+ /* Reached to end of table or int error */
+ return -ERESTARTSYS;
+ 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 0; /* Seek succeeded */
+}
+
+
+
+
+/*
+ * Directory handling - Move directory index next
+ */
+static int dir_next ( /* 0:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not stretch */
+ FF_DIR *dj, /* Pointer to directory object */
+ int stretch /* 0: Do not stretch table, 1: Stretch table if needed */
+)
+{
+ DWORD clst;
+ WORD i;
+
+
+ i = dj->index + 1;
+ if (!i || !dj->sect) /* Report EOT when index has reached 65535 */
+ return -ENOENT;
+
+ 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 -ENOENT;
+ }
+ 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 -ERESTARTSYS;
+
+ if (clst == 0xFFFFFFFF)
+ return -EIO;
+
+ if (clst >= dj->fs->n_fatent) { /* When it reached end of dynamic table */
+#ifdef CONFIG_FS_FAT_WRITE
+ BYTE c;
+
+ if (!stretch)
+ return -ENOENT; /* When do not stretch, report EOT */
+
+ clst = create_chain(dj->fs, dj->clust); /* Stretch cluster chain */
+
+ if (clst == 0)
+ return -ENOSPC; /* No free cluster */
+
+ if (clst == 1)
+ return -ERESTARTSYS;
+
+ if (clst == 0xFFFFFFFF)
+ return -EIO;
+
+ /* Clean-up stretched table */
+ if (move_window(dj->fs, 0))
+ return -EIO; /* Flush active window */
+
+ memset(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 -EIO;
+ dj->fs->winsect++;
+ }
+ dj->fs->winsect -= c; /* Rewind window address */
+#else
+ return -ENOENT; /* 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 0;
+}
+
+/*
+ * LFN handling - Test/Pick/Fit an LFN segment from/to directory entry
+ */
+#ifdef CONFIG_FS_FAT_LFN
+
+/* Offset of LFN chars in the directory entry */
+static const BYTE LfnOfs[] = {1,3,5,7,9,14,16,18,20,22,24,28,30};
+
+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 */
+)
+{
+ UINT i, s;
+ WCHAR wc, uc;
+
+ /* Get offset in the LFN buffer */
+ i = ((dir[LDIR_Ord] & ~LLE) - 1) * 13;
+ s = 0; wc = 1;
+ do {
+ /* Pick an LFN character from the entry */
+ uc = LD_WORD(dir+LfnOfs[s]);
+ if (wc) {
+ /* Last char has not been processed */
+ wc = ff_wtoupper(uc);
+ 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 */
+}
+
+
+
+static
+int pick_lfn ( /* 1:Succeeded, 0:Buffer overflow */
+ WCHAR *lfnbuf, /* Pointer to the Unicode-LFN buffer */
+ BYTE *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 {
+ /* Pick an LFN character from the entry */
+ uc = LD_WORD(dir+LfnOfs[s]);
+ 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;
+}
+
+
+#ifdef CONFIG_FS_FAT_WRITE
+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 */
+)
+{
+ 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 */
+}
+
+#endif
+#endif
+
+
+
+/*
+ * Create numbered name
+ */
+#ifdef CONFIG_FS_FAT_LFN
+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 ns[8], c;
+ UINT i, j;
+
+
+ memcpy(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);
+}
+#endif
+
+/*
+ * Calculate sum of an SFN
+ */
+#ifdef CONFIG_FS_FAT_LFN
+static BYTE sum_sfn (
+ const BYTE *dir /* Ptr to directory entry */
+)
+{
+ BYTE sum = 0;
+ UINT n = 11;
+
+ do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n);
+ return sum;
+}
+#endif
+
+/*
+ * Directory handling - Find an object in the directory
+ */
+
+static int dir_find (
+ FF_DIR *dj /* Pointer to the directory object linked to the file name */
+)
+{
+ int res;
+ BYTE c, *dir;
+#ifdef CONFIG_FS_FAT_LFN
+ BYTE a, ord, sum;
+#endif
+
+ res = dir_sdi(dj, 0); /* Rewind directory object */
+ if (res != 0)
+ return res;
+
+#ifdef CONFIG_FS_FAT_LFN
+ ord = sum = 0xFF;
+#endif
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != 0)
+ break;
+ dir = dj->dir; /* Ptr to the directory entry of current index */
+ c = dir[DIR_Name];
+ if (c == 0) {
+ /* Reached to end of table */
+ res = -ENOENT;
+ break;
+ }
+#ifdef CONFIG_FS_FAT_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? */
+
+ /* Reset LFN sequence */
+ ord = 0xFF;
+ dj->lfn_idx = 0xFFFF;
+ if (!(dj->fn[NS] & NS_LOSS) && !memcmp(dir, dj->fn, 11))
+ break; /* SFN matched? */
+ }
+ }
+#else /* Non LFN configuration */
+ if (!(dir[DIR_Attr] & AM_VOL) && !memcmp(dir, dj->fn, 11)) /* Is it a valid entry? */
+ break;
+#endif
+ res = dir_next(dj, 0); /* Next entry */
+ } while (res == 0);
+
+ return res;
+}
+
+
+
+
+/*
+ * Read an object from the directory
+ */
+static int dir_read (
+ FF_DIR *dj /* Pointer to the directory object that pointing the entry to be read */
+)
+{
+ int res;
+ BYTE c, *dir;
+#ifdef CONFIG_FS_FAT_LFN
+ BYTE a, ord = 0xFF, sum = 0xFF;
+#endif
+
+ res = -ENOENT;
+ while (dj->sect) {
+ res = move_window(dj->fs, dj->sect);
+ if (res != 0)
+ break;
+ dir = dj->dir; /* Ptr to the directory entry of current index */
+ c = dir[DIR_Name];
+ if (c == 0) {
+ /* Reached to end of table */
+ res = -ENOENT;
+ break;
+ }
+#ifdef CONFIG_FS_FAT_LFN /* LFN configuration */
+ a = dir[DIR_Attr] & AM_MASK;
+ if (c == DDE || 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 && c != '.' && !(dir[DIR_Attr] & AM_VOL)) /* Is it a valid entry? */
+ break;
+#endif
+ res = dir_next(dj, 0); /* Next entry */
+ if (res != 0)
+ break;
+ }
+
+ if (res != 0)
+ dj->sect = 0;
+
+ return res;
+}
+
+/*
+ * Register an object to the directory
+ */
+#ifdef CONFIG_FS_FAT_WRITE
+static
+int dir_register ( /* 0:Successful, FR_DENIED:No free entry or too many SFN collision, -EIO:Disk error */
+ FF_DIR *dj /* Target directory with object name to be created */
+)
+{
+ int res;
+ BYTE c, *dir;
+#ifdef CONFIG_FS_FAT_LFN /* LFN configuration */
+ WORD n, ne, is;
+ BYTE sn[12], *fn, sum;
+ WCHAR *lfn;
+
+
+ fn = dj->fn; lfn = dj->lfn;
+ memcpy(sn, fn, 12);
+
+ 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 != 0)
+ break;
+ }
+ if (n == 100)
+ return -ENOSPC; /* Abort if too many collisions */
+ if (res != -ENOENT)
+ 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 != 0)
+ return res;
+ n = is = 0;
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != 0)
+ 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 == 0);
+
+ if (res == 0 && ne > 1) {
+ /* Initialize LFN entry if needed */
+ res = dir_sdi(dj, is);
+ if (res == 0) {
+ 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 != 0)
+ break;
+ fit_lfn(dj->lfn, dj->dir, (BYTE)ne, sum);
+ dj->fs->wflag = 1;
+ res = dir_next(dj, 0); /* Next entry */
+ } while (res == 0 && --ne);
+ }
+ }
+
+#else /* Non LFN configuration */
+ res = dir_sdi(dj, 0);
+ if (res == 0) {
+ do { /* Find a blank entry for the SFN */
+ res = move_window(dj->fs, dj->sect);
+ if (res != 0)
+ 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 == 0);
+ }
+#endif
+
+ if (res == 0) { /* Initialize the SFN entry */
+ res = move_window(dj->fs, dj->sect);
+ if (res == 0) {
+ dir = dj->dir;
+ memset(dir, 0, SZ_DIR); /* Clean the entry */
+ memcpy(dir, dj->fn, 11); /* Put SFN */
+#ifdef CONFIG_FS_FAT_LFN
+ dir[DIR_NTres] = *(dj->fn+NS) & (NS_BODY | NS_EXT); /* Put NT flag */
+#endif
+ dj->fs->wflag = 1;
+ }
+ }
+
+ return res;
+}
+#endif /* CONFIG_FS_FAT_WRITE */
+
+/*
+ * Remove an object from the directory
+ */
+#if defined CONFIG_FS_FAT_WRITE
+static int dir_remove ( /* 0: Successful, -EIO: A disk error */
+ FF_DIR *dj /* Directory object pointing the entry to be removed */
+)
+{
+ int res;
+#ifdef CONFIG_FS_FAT_LFN /* LFN configuration */
+ WORD i;
+
+ i = dj->index; /* SFN index */
+ /* Goto the SFN or top of the LFN entries */
+ res = dir_sdi(dj, (WORD)((dj->lfn_idx == 0xFFFF) ? i : dj->lfn_idx));
+ if (res == 0) {
+ do {
+ res = move_window(dj->fs, dj->sect);
+ if (res != 0)
+ 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 == 0);
+ if (res == -ENOENT)
+ res = -ERESTARTSYS;
+ }
+
+#else /* Non LFN configuration */
+ res = dir_sdi(dj, dj->index);
+ if (res == 0) {
+ res = move_window(dj->fs, dj->sect);
+ if (res == 0) {
+ *dj->dir = DDE; /* Mark the entry "deleted" */
+ dj->fs->wflag = 1;
+ }
+ }
+#endif
+
+ return res;
+}
+#endif /* CONFIG_FS_FAT_WRITE */
+
+/*
+ * Pick a segment and create the object name in directory form
+ */
+static int create_name (
+ FF_DIR *dj, /* 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 */
+#endif
+
+#ifdef CONFIG_FS_FAT_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 -ENAMETOOLONG;
+#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 -ENAMETOOLONG; /* Reject invalid sequence */
+ w = (w << 8) + b; /* Create a DBC */
+ }
+ w = ff_convert(w, 1); /* Convert ANSI/OEM to Unicode */
+ if (!w) return -ENAMETOOLONG; /* Reject invalid code */
+#endif
+ if (w < 0x80 && strchr("\"*:<>\?|\x7F", w)) /* Reject illegal chars for LFN */
+ return -ENAMETOOLONG;
+ 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 */
+ while (di) { /* Strip trailing spaces and dots */
+ w = lfn[di-1];
+ if (w != ' ' && w != '.')
+ break;
+ di--;
+ }
+ if (!di) return -EINVAL; /* Reject nul string */
+
+ lfn[di] = 0; /* LFN is created */
+
+ /* Create SFN in directory form */
+ memset(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 */
+#ifdef _EXCVT
+ w = ff_convert(w, 0); /* Unicode -> OEM code */
+ if (w)
+ w = excvt[w - 0x80]; /* Convert extended char to upper (SBCS) */
+#else
+ w = ff_convert(ff_wtoupper(w), 0); /* Upper converted Unicode -> OEM code */
+#endif
+ cf |= NS_LFN; /* Force create LFN entry */
+ }
+
+ if (_DF1S && w >= 0x100) { /* 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 || strchr("+,;=[]", w)) { /* Replace illegal chars for SFN */
+ w = '_'; cf |= NS_LOSS | NS_LFN;/* Lossy conversion */
+ } else {
+ if (isupper(w)) {
+ b |= 2;
+ } else {
+ if (islower(w)) {
+ 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 0;
+
+#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;
+ memset(sfn, ' ', 11);
+ si = i = b = 0; ni = 8;
+ for (;;) {
+ c = (BYTE)p[si++];
+ if (c <= ' ' || c == '/' || c == '\\') break; /* Break on end of segment */
+ if (c == '.' || i >= ni) {
+ if (ni != 8 || c != '.')
+ return -EINVAL;
+ i = 8; ni = 11;
+ b <<= 2; continue;
+ }
+ if (c >= 0x80) { /* Extended char? */
+ b |= 3; /* Eliminate NT flag */
+#ifdef _EXCVT
+ c = excvt[c-0x80]; /* Upper conversion (SBCS) */
+#else
+#if !_DF1S /* ASCII only cfg */
+ return -EINVAL;
+#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 -EINVAL;
+ sfn[i++] = c;
+ sfn[i++] = d;
+ } else { /* Single byte code */
+ if (strchr("\"*+,:;<=>\?[]|\x7F", c)) /* Reject illegal chrs for SFN */
+ return -EINVAL;
+ if (isupper(c)) {
+ b |= 2;
+ } else {
+ if (islower(c)) {
+ 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 -EINVAL; /* 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 0;
+#endif
+}
+
+/*
+ * Get file information from directory entry
+ */
+static void get_fileinfo ( /* No return code */
+ FF_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;
+#ifdef CONFIG_FS_FAT_LFN
+ if ((nt & NS_BODY) && isupper(c))
+ c += 0x20;
+#endif
+#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;
+#ifdef CONFIG_FS_FAT_LFN
+ if ((nt & NS_EXT) && isupper(c))
+ c += 0x20;
+#endif
+#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 */
+
+#ifdef CONFIG_FS_FAT_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) {
+ /* Could not convert, no LFN */
+ i = 0;
+ break;
+ }
+ /* Put 1st byte if it is a DBC (always false on SBCS cfg) */
+ if (_DF1S && w >= 0x100)
+ 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
+}
+
+/*
+ * Follow a file path
+ */
+static
+int follow_path ( /* 0(0): successful, !=0: error code */
+ FF_DIR *dj, /* Directory object to return last directory and found object */
+ const TCHAR *path /* Full-path string to find a file or directory */
+)
+{
+ int res;
+ BYTE *dir, ns;
+
+ if (*path == '/' || *path == '\\') /* Strip heading separator if exist */
+ path++;
+ dj->sclust = 0; /* Start from the root dir */
+
+ if ((UINT)*path < ' ') {
+ /* Nul path means the start directory itself */
+ res = dir_sdi(dj, 0);
+ dj->dir = 0;
+ return res;
+ }
+
+ /* Follow path */
+ for (;;) {
+ res = create_name(dj, &path); /* Get a segment */
+ if (res != 0)
+ break;
+ res = dir_find(dj); /* Find it */
+ ns = *(dj->fn+NS);
+ if (res != 0) { /* Failed to find the object */
+ if (res != -ENOENT)
+ break; /* Abort if any hard error occured */
+ /* Object not found */
+ if (!(ns & NS_LAST))
+ res = -ENOENT;
+ 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 = -ENOTDIR;
+ break;
+ }
+ dj->sclust = LD_CLUST(dir);
+ }
+
+ return res;
+}
+
+/*
+ * Load boot record and check if it is an FAT boot record
+ */
+static int check_fs ( /* 0:The FAT BR, 1:Valid BR but not an 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 ret;
+
+ /* Load boot record */
+ ret = disk_read(fs, fs->win, sect, 1);
+ if (ret)
+ return ret;
+ /* Check record signature (always placed at offset 510 even if the sector size is>512) */
+ if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)
+ return -ENODEV;
+
+ /* Check "FAT" string */
+ if ((LD_DWORD(&fs->win[BS_FilSysType]) & 0xFFFFFF) == 0x544146)
+ return 0;
+
+ if ((LD_DWORD(&fs->win[BS_FilSysType32]) & 0xFFFFFF) == 0x544146)
+ return 0;
+
+ return -ENODEV;
+}
+
+/*
+ * Check if the file system object is valid or not
+ */
+static int chk_mounted ( /* 0(0): successful, !=0: any error occurred */
+ FATFS *fs, /* Pointer to pointer to the found file system object */
+ BYTE chk_wp /* !=0: Check media write protection for write access */
+)
+{
+ BYTE fmt, b;
+ DWORD bsect, fasize, tsect, sysect, nclst, szbfat;
+ WORD nrsv;
+
+ INIT_LIST_HEAD(&fs->dirtylist);
+
+ /* The logical drive must be mounted. */
+ /* Following code attempts to mount a volume. (analyze BPB and initialize the fs object) */
+
+ fs->fs_type = 0; /* Clear the file system object */
+#if _MAX_SS != 512 /* Get disk sector size (variable sector size cfg only) */
+ if (disk_ioctl(fs, GET_SECTOR_SIZE, &fs->ssize) != RES_OK)
+ return -EIO;
+#endif
+ /* Search FAT partition on the drive. Supports only generic partitionings, FDISK and SFD. */
+ fmt = check_fs(fs, bsect = 0); /* Check sector 0 if it is a VBR */
+ if (fmt)
+ return fmt; /* No FAT volume is found */
+
+ /* Following code initializes the file system object */
+
+ /* (BPB_BytsPerSec must be equal to the physical sector size) */
+ if (LD_WORD(fs->win+BPB_BytsPerSec) != SS(fs))
+ return -EINVAL;
+
+ /* Number of sectors per FAT */
+ fasize = LD_WORD(fs->win+BPB_FATSz16);
+ if (!fasize)
+ fasize = LD_DWORD(fs->win+BPB_FATSz32);
+ fs->fsize = fasize;
+
+ /* Number of FAT copies */
+ fs->n_fats = b = fs->win[BPB_NumFATs];
+ if (b != 1 && b != 2)
+ return -EINVAL; /* (Must be 1 or 2) */
+
+ /* Number of sectors for FAT area */
+ fasize *= b;
+
+ /* Number of sectors per cluster */
+ fs->csize = b = fs->win[BPB_SecPerClus];
+ if (!b || (b & (b - 1)))
+ return -EINVAL; /* (Must be power of 2) */
+
+ /* Number of root directory entries */
+ fs->n_rootdir = LD_WORD(fs->win+BPB_RootEntCnt);
+ if (fs->n_rootdir % (SS(fs) / SZ_DIR))
+ return -EINVAL; /* (BPB_RootEntCnt must be sector aligned) */
+
+ /* Number of sectors on the volume */
+ tsect = LD_WORD(fs->win+BPB_TotSec16);
+ if (!tsect) tsect = LD_DWORD(fs->win+BPB_TotSec32);
+
+ /* Number of reserved sectors */
+ nrsv = LD_WORD(fs->win+BPB_RsvdSecCnt);
+ if (!nrsv)
+ return -EINVAL; /* (BPB_RsvdSecCnt must not be 0) */
+
+ /* Determine the FAT sub type */
+ /* RSV+FAT+FF_DIR */
+ sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZ_DIR);
+ if (tsect < sysect)
+ return -EINVAL; /* (Invalid volume size) */
+
+ /* Number of clusters */
+ nclst = (tsect - sysect) / fs->csize;
+ if (!nclst)
+ return -EINVAL; /* (Invalid volume size) */
+ fmt = FS_FAT12;
+ if (nclst >= MIN_FAT16)
+ fmt = FS_FAT16;
+ if (nclst >= MIN_FAT32)
+ fmt = FS_FAT32;
+
+ /* Boundaries and Limits */
+ /* Number of FAT entries */
+ fs->n_fatent = nclst + 2;
+ /* Data start sector */
+ fs->database = bsect + sysect;
+ /* FAT start sector */
+ fs->fatbase = bsect + nrsv;
+ if (fmt == FS_FAT32) {
+ if (fs->n_rootdir)
+ return -EINVAL; /* (BPB_RootEntCnt must be 0) */
+ /* Root directory start cluster */
+ fs->dirbase = LD_DWORD(fs->win+BPB_RootClus);
+ /* (Required FAT size) */
+ szbfat = fs->n_fatent * 4;
+ } else {
+ if (!fs->n_rootdir)
+ return -EINVAL;/* (BPB_RootEntCnt must not be 0) */
+ /* Root directory start sector */
+ fs->dirbase = fs->fatbase + fasize;
+ /* (Required FAT size) */
+ szbfat = (fmt == FS_FAT16) ?
+ fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
+ }
+ /* (BPB_FATSz must not be less than required) */
+ if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs))
+ return -EINVAL;
+
+#ifdef CONFIG_FS_FAT_WRITE
+ /* 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, 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);
+ }
+ }
+#endif
+ fs->fs_type = fmt; /* FAT sub-type */
+ fs->winsect = 0; /* Invalidate sector cache */
+ fs->wflag = 0;
+
+ return 0;
+}
+
+/*
+ * Mount/Unmount a Logical Drive
+ */
+int f_mount (
+ FATFS *fs /* Pointer to new file system object (NULL for unmount)*/
+)
+{
+ fs->fs_type = 0; /* Clear new fs object */
+
+ chk_mounted(fs, 0);
+
+ return 0;
+}
+
+/*
+ * Open or Create a File
+ */
+int f_open (
+ FATFS *fatfs,
+ 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 */
+)
+{
+ int res = 0;
+ FF_DIR dj;
+ BYTE *dir;
+ DEF_NAMEBUF;
+
+
+ fp->fs = 0; /* Clear file object */
+
+#ifdef CONFIG_FS_FAT_WRITE
+ mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
+ dj.fs = fatfs;
+#else
+ mode &= FA_READ;
+ dj.fs = fatfs;
+#endif
+ INIT_BUF(dj);
+ if (res == 0)
+ res = follow_path(&dj, path); /* Follow the file path */
+ dir = dj.dir;
+
+#ifdef CONFIG_FS_FAT_WRITE /* R/W configuration */
+ if (res == 0) {
+ if (!dir) /* Current dir itself */
+ res = -EISDIR;
+ }
+ /* Create or Open a file */
+ if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
+ DWORD dw, cl;
+
+ if (res != 0) { /* No file, create new */
+ if (res == -ENOENT) /* There is no file to open, create a new entry */
+ res = dir_register(&dj);
+ mode |= FA_CREATE_ALWAYS; /* File is created */
+ dir = dj.dir; /* New entry */
+ } else { /* Any object is already existing */
+ if (dir[DIR_Attr] & AM_RDO) {
+ res = -EROFS;
+ } else if (dir[DIR_Attr] & AM_DIR) { /* Cannot overwrite it (R/O or FF_DIR) */
+ res = -EISDIR;
+ } else {
+ if (mode & FA_CREATE_NEW) /* Cannot create as new file */
+ res = -EEXIST;
+ }
+ }
+ if (res == 0 && (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(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 == 0) {
+ dj.fs->last_clust = cl - 1; /* Reuse the cluster hole */
+ res = move_window(dj.fs, dw);
+ }
+ }
+ }
+ } else { /* Open an existing file */
+ if (res == 0) { /* Follow succeeded */
+ if (dir[DIR_Attr] & AM_DIR) { /* It is a directory */
+ res = -EISDIR;
+ } else {
+ if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
+ res = -EROFS;
+ }
+ }
+ }
+ if (res == 0) {
+ 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;
+ }
+
+#else /* R/O configuration */
+ if (res == 0) { /* Follow succeeded */
+ if (!dir) { /* Current dir itself */
+ res = -EISDIR;
+ } else {
+ if (dir[DIR_Attr] & AM_DIR) /* It is a directory */
+ res = -EISDIR;
+ }
+ }
+#endif
+ FREE_BUF();
+
+ if (res == 0) {
+ fp->flag = mode; /* File access mode */
+ fp->sclust = LD_CLUST(dir); /* File start cluster */
+ fp->fsize = LD_DWORD(dir+DIR_FileSize); /* File size */
+ fp->fptr = 0; /* File pointer */
+ fp->dsect = 0;
+ fp->fs = dj.fs;
+ }
+
+ return res;
+}
+
+
+
+
+/*
+ * Read File
+ */
+int 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 */
+)
+{
+ DWORD clst, sect, remain;
+ UINT rcnt, cc;
+ BYTE csect, *rbuff = buff;
+
+ *br = 0; /* Initialize byte counter */
+
+ if (fp->flag & FA__ERROR) /* Aborted file? */
+ return -ERESTARTSYS;
+ if (!(fp->flag & FA_READ)) /* Check access mode */
+ return -EROFS;
+ remain = fp->fsize - fp->fptr;
+ if (btr > remain)
+ btr = (UINT)remain; /* Truncate btr by remaining bytes */
+
+ /* Repeat until all data read */
+ for ( ; btr; 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 */
+ clst = get_fat(fp->fs, fp->clust); /* Follow cluster chain on the FAT */
+ }
+ if (clst < 2)
+ ABORT(fp->fs, -ERESTARTSYS);
+ if (clst == 0xFFFFFFFF)
+ ABORT(fp->fs, -EIO);
+ fp->clust = clst; /* Update current cluster */
+ }
+ sect = clust2sect(fp->fs, fp->clust); /* Get current sector */
+ if (!sect)
+ ABORT(fp->fs, -ERESTARTSYS);
+ 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, rbuff, sect, (BYTE)cc) != RES_OK)
+ ABORT(fp->fs, -EIO);
+#if defined CONFIG_FS_FAT_WRITE
+ /* Replace one of the read sectors with cached data if it contains a dirty sector */
+ if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)
+ memcpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
+#endif
+ rcnt = SS(fp->fs) * cc; /* Number of bytes transferred */
+ continue;
+ }
+ if (fp->dsect != sect) { /* Load data sector if not in cache */
+#ifdef CONFIG_FS_FAT_WRITE
+ if (fp->flag & FA__DIRTY) { /* Write-back dirty sector cache */
+ if (disk_write(fp->fs, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, -EIO);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ if (disk_read(fp->fs, fp->buf, sect, 1) != RES_OK) /* Fill sector cache */
+ ABORT(fp->fs, -EIO);
+ }
+ fp->dsect = sect;
+ }
+ rcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs)); /* Get partial sector data from sector buffer */
+ if (rcnt > btr)
+ rcnt = btr;
+ memcpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt); /* Pick partial sector */
+ }
+
+ return 0;
+}
+
+
+
+
+#ifdef CONFIG_FS_FAT_WRITE
+/*
+ * Write File
+ */
+int 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 */
+)
+{
+ DWORD clst, sect;
+ UINT wcnt, cc;
+ const BYTE *wbuff = buff;
+ BYTE csect;
+
+ *bw = 0; /* Initialize byte counter */
+
+ if (fp->flag & FA__ERROR) /* Aborted file? */
+ return -ERESTARTSYS;
+ if (!(fp->flag & FA_WRITE)) /* Check access mode */
+ return -EROFS;
+ if ((DWORD)(fp->fsize + btw) < fp->fsize)
+ btw = 0; /* File size cannot reach 4GB */
+
+ /* Repeat until all data written */
+ for ( ; btw; wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
+ /* On the sector boundary? */
+ if ((fp->fptr % SS(fp->fs)) == 0) {
+ /* Sector offset in the cluster */
+ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));
+ /* On the cluster boundary? */
+ if (!csect) {
+ /* On the top of the file? */
+ if (fp->fptr == 0) {
+ clst = fp->sclust; /* Follow from the origin */
+ if (clst == 0) /* When no cluster is allocated, */
+ /* Create a new cluster chain */
+ fp->sclust = clst = create_chain(fp->fs, 0);
+ } else {
+ /* Middle or end of the file */
+ /* Follow or stretch cluster chain on the FAT */
+ clst = create_chain(fp->fs, fp->clust);
+ }
+ if (clst == 0)
+ break; /* Could not allocate a new cluster (disk full) */
+ if (clst == 1)
+ ABORT(fp->fs, -ERESTARTSYS);
+ if (clst == 0xFFFFFFFF)
+ ABORT(fp->fs, -EIO);
+ fp->clust = clst; /* Update current cluster */
+ }
+ if (fp->flag & FA__DIRTY) { /* Write-back sector cache */
+ printf("wr sector cache\n");
+ if (disk_write(fp->fs, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, -EIO);
+ fp->flag &= ~FA__DIRTY;
+ }
+ sect = clust2sect(fp->fs, fp->clust); /* Get current sector */
+ if (!sect)
+ ABORT(fp->fs, -ERESTARTSYS);
+ 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, wbuff, sect, (BYTE)cc) != RES_OK)
+ ABORT(fp->fs, -EIO);
+ if (fp->dsect - sect < cc) {
+ /* Refill sector cache if it gets invalidated by the direct write */
+ memcpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
+ fp->flag &= ~FA__DIRTY;
+ }
+ wcnt = SS(fp->fs) * cc; /* Number of bytes transferred */
+ continue;
+ }
+ if (fp->dsect != sect) {
+ /* Fill sector cache with file data */
+ if (fp->fptr < fp->fsize &&
+ disk_read(fp->fs, fp->buf, sect, 1) != RES_OK)
+ ABORT(fp->fs, -EIO);
+ }
+
+ fp->dsect = sect;
+ }
+ /* Put partial sector into file I/O buffer */
+ wcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));
+ if (wcnt > btw)
+ wcnt = btw;
+ memcpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt); /* Fit partial sector */
+ fp->flag |= FA__DIRTY;
+ }
+
+ if (fp->fptr > fp->fsize)
+ fp->fsize = fp->fptr; /* Update file size if needed */
+
+ fp->flag |= FA__WRITTEN; /* Set file change flag */
+
+ return 0;
+}
+
+/*
+ * Synchronize the File Object
+ */
+int f_sync (
+ FIL *fp /* Pointer to the file object */
+)
+{
+ int res;
+ DWORD tim;
+ BYTE *dir;
+
+ /* Has the file been written? */
+ if (!(fp->flag & FA__WRITTEN))
+ return 0;
+
+ if (fp->flag & FA__DIRTY) {
+ if (disk_write(fp->fs, fp->buf, fp->dsect, 1) != RES_OK)
+ return -EIO;
+ fp->flag &= ~FA__DIRTY;
+ }
+
+ /* Update the directory entry */
+ res = move_window(fp->fs, fp->dir_sect);
+ if (res)
+ return res;
+
+ 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);
+ fp->flag &= ~FA__WRITTEN;
+ fp->fs->wflag = 1;
+ res = sync(fp->fs);
+
+ flush_dirty_fat(fp->fs);
+
+ return res;
+}
+
+#endif /* CONFIG_FS_FAT_WRITE */
+
+/*
+ * Close File
+ */
+int f_close (
+ FIL *fp /* Pointer to the file object to be closed */
+)
+{
+#ifndef CONFIG_FS_FAT_WRITE
+ fp->fs = 0; /* Discard file object */
+ return 0;
+#else
+ int res;
+
+ /* Flush cached data */
+ res = f_sync(fp);
+ if (res == 0)
+ fp->fs = 0; /* Discard file object */
+ return res;
+#endif
+}
+
+/*
+ * Seek File R/W Pointer
+ */
+int f_lseek (
+ FIL *fp, /* Pointer to the file object */
+ DWORD ofs /* File pointer from top of file */
+)
+{
+ DWORD clst, bcs, nsect, ifptr;
+ int res = 0;
+
+ if (fp->flag & FA__ERROR) /* Check abort flag */
+ return -ERESTARTSYS;
+
+ if (ofs > fp->fsize /* In read-only mode, clip offset with the file size */
+#ifdef CONFIG_FS_FAT_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 */
+#ifdef CONFIG_FS_FAT_WRITE
+ if (clst == 0) { /* If no cluster chain, create a new chain */
+ clst = create_chain(fp->fs, 0);
+ if (clst == 1)
+ ABORT(fp->fs, -ERESTARTSYS);
+ if (clst == 0xFFFFFFFF)
+ ABORT(fp->fs, -EIO);
+ fp->sclust = clst;
+ }
+#endif
+ fp->clust = clst;
+ }
+ if (clst != 0) {
+ while (ofs > bcs) { /* Cluster following loop */
+#ifdef CONFIG_FS_FAT_WRITE
+ if (fp->flag & FA_WRITE) { /* Check if in write mode or not */
+ /* Force stretch if in write mode */
+ clst = create_chain(fp->fs, clst);
+ /* When disk gets full, clip file size */
+ if (clst == 0) {
+ ofs = bcs;
+ break;
+ }
+ } else
+#endif
+ /* Follow cluster chain if not in write mode */
+ clst = get_fat(fp->fs, clst);
+ if (clst == 0xFFFFFFFF)
+ ABORT(fp->fs, -EIO);
+ if (clst <= 1 || clst >= fp->fs->n_fatent)
+ ABORT(fp->fs, -ERESTARTSYS);
+ 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, -ERESTARTSYS);
+ nsect += ofs / SS(fp->fs);
+ }
+ }
+ }
+ if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) { /* Fill sector cache if needed */
+#ifdef CONFIG_FS_FAT_WRITE
+ if (fp->flag & FA__DIRTY) { /* Write-back dirty sector cache */
+ if (disk_write(fp->fs, fp->buf, fp->dsect, 1) != RES_OK)
+ ABORT(fp->fs, -EIO);
+ fp->flag &= ~FA__DIRTY;
+ }
+#endif
+ if (disk_read(fp->fs, fp->buf, nsect, 1) != RES_OK) /* Fill sector cache */
+ ABORT(fp->fs, -EIO);
+ fp->dsect = nsect;
+ }
+#ifdef CONFIG_FS_FAT_WRITE
+ if (fp->fptr > fp->fsize) { /* Set file change flag if the file size is extended */
+ fp->fsize = fp->fptr;
+ fp->flag |= FA__WRITTEN;
+ }
+#endif
+
+ return res;
+}
+
+/*
+ * Create a Directroy Object
+ */
+int f_opendir (
+ FATFS *fatfs,
+ FF_DIR *dj, /* Pointer to directory object to create */
+ const TCHAR *path /* Pointer to the directory path */
+)
+{
+ int res;
+ DEF_NAMEBUF;
+
+ dj->fs = fatfs;
+
+ INIT_BUF(*dj);
+ res = follow_path(dj, path); /* Follow the path to the directory */
+ FREE_BUF();
+
+ if (res)
+ return res;
+
+ 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(dj->dir);
+ } else {
+ /* The object is not a directory */
+ return -ENOTDIR;
+ }
+ }
+
+ res = dir_sdi(dj, 0); /* Rewind dir */
+
+ return res;
+}
+
+
+
+
+/*
+ * Read Directory Entry in Sequense
+ */
+int f_readdir (
+ FF_DIR *dj, /* Pointer to the open directory object */
+ FILINFO *fno /* Pointer to file information to return */
+)
+{
+ int res;
+ DEF_NAMEBUF;
+
+ if (!fno) {
+ res = dir_sdi(dj, 0); /* Rewind the directory object */
+ return res;
+ }
+
+ INIT_BUF(*dj);
+ res = dir_read(dj); /* Read an directory item */
+ if (res == -ENOENT) { /* Reached end of dir */
+ dj->sect = 0;
+ res = 0;
+ goto out;
+ }
+
+ /* A valid entry is found */
+ get_fileinfo(dj, fno); /* Get the object information */
+ res = dir_next(dj, 0); /* Increment index for next */
+ if (res == -ENOENT) {
+ dj->sect = 0;
+ res = 0;
+ }
+out:
+ FREE_BUF();
+
+ return res;
+}
+
+/*
+ * Get File Status
+ */
+int f_stat (
+ FATFS *fatfs,
+ const TCHAR *path, /* Pointer to the file path */
+ FILINFO *fno /* Pointer to file information to return */
+)
+{
+ int res;
+ FF_DIR dj;
+ DEF_NAMEBUF;
+
+ dj.fs = fatfs;
+
+ INIT_BUF(dj);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res == 0) { /* Follow completed */
+ if (dj.dir) /* Found an object */
+ get_fileinfo(&dj, fno);
+ else /* It is root dir */
+ res = -ENOENT;
+ }
+ FREE_BUF();
+
+ return res;
+}
+
+#ifdef CONFIG_FS_FAT_WRITE
+/*
+ * Get Number of Free Clusters
+ */
+int f_getfree (
+ FATFS *fatfs,
+ const TCHAR *path, /* Pointer to the logical drive number (root dir) */
+ DWORD *nclst /* Pointer to the variable to return number of free clusters */
+)
+{
+ int res = 0;
+ DWORD n, clst, sect, stat;
+ UINT i;
+ BYTE fat, *p;
+
+
+ /* If free_clust is valid, return it without full cluster scan */
+ if (fatfs->free_clust <= fatfs->n_fatent - 2) {
+ *nclst = fatfs->free_clust;
+ return 0;
+ }
+
+ /* Get number of free clusters */
+ fat = fatfs->fs_type;
+ n = 0;
+ if (fat == FS_FAT12) {
+ clst = 2;
+ do {
+ stat = get_fat(fatfs, clst);
+ if (stat == 0xFFFFFFFF) {
+ res = -EIO;
+ break;
+ }
+ if (stat == 1) {
+ res = -ERESTARTSYS;
+ break;
+ }
+ if (stat == 0) n++;
+ } while (++clst < fatfs->n_fatent);
+ } else {
+ clst = fatfs->n_fatent;
+ sect = fatfs->fatbase;
+ i = 0; p = 0;
+ do {
+ if (!i) {
+ res = move_window(fatfs, sect++);
+ if (res != 0) break;
+ p = fatfs->win;
+ i = SS(fatfs);
+ }
+ 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);
+ }
+ fatfs->free_clust = n;
+ if (fat == FS_FAT32)
+ fatfs->fsi_flag = 1;
+ *nclst = n;
+
+ return res;
+}
+
+/*
+ * Truncate File
+ */
+int f_truncate (
+ FIL *fp /* Pointer to the file object */
+)
+{
+ int res = 0;
+ DWORD ncl;
+
+ if (fp->flag & FA__ERROR) { /* Check abort flag */
+ return -ERESTARTSYS;
+ } else {
+ if (!(fp->flag & FA_WRITE)) /* Check access mode */
+ return -EROFS;
+ }
+
+ if (fp->fsize <= fp->fptr)
+ return 0;
+
+ 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);
+ if (ncl == 0xFFFFFFFF)
+ return -EIO;
+ if (ncl == 1)
+ return -ERESTARTSYS;
+ if (ncl < fp->fs->n_fatent) {
+ res = put_fat(fp->fs, fp->clust, 0x0FFFFFFF);
+ if (res)
+ return res;
+ res = remove_chain(fp->fs, ncl);
+ }
+ }
+
+ return res;
+}
+
+/*
+ * Delete a File or Directory
+ */
+int f_unlink (
+ FATFS *fatfs,
+ const TCHAR *path /* Pointer to the file or directory path */
+)
+{
+ int res;
+ FF_DIR dj, sdj;
+ BYTE *dir;
+ DWORD dclst;
+ DEF_NAMEBUF;
+
+ dj.fs = fatfs;
+
+ INIT_BUF(dj);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res)
+ goto out;
+
+ if (dj.fn[NS] & NS_DOT) {
+ res = -EINVAL; /* Cannot remove dot entry */
+ goto out;
+ }
+
+ /* The object is accessible */
+ dir = dj.dir;
+ if (!dir) {
+ res = -EINVAL; /* Cannot remove the start directory */
+ goto out;
+ }
+
+ if (dir[DIR_Attr] & AM_RDO) {
+ res = -EROFS; /* Cannot remove R/O object */
+ goto out;
+ }
+
+ dclst = LD_CLUST(dir);
+ if (dir[DIR_Attr] & AM_DIR) { /* Is it a sub-dir? */
+ if (dclst < 2) {
+ res = -ERESTARTSYS;
+ goto out;
+ }
+ memcpy(&sdj, &dj, sizeof(FF_DIR)); /* Check if the sub-dir is empty or not */
+ sdj.sclust = dclst;
+ res = dir_sdi(&sdj, 2); /* Exclude dot entries */
+ if (res)
+ goto out;
+
+ res = dir_read(&sdj);
+ if (res == 0) {
+ res = -ENOTEMPTY; /* Not empty dir */
+ goto out;
+ }
+ if (res == -ENOENT)
+ res = 0; /* Empty */
+ if (res)
+ goto out;
+ }
+
+ res = dir_remove(&dj); /* Remove the directory entry */
+ if (res)
+ goto out;
+
+ if (dclst) {
+ /* Remove the cluster chain if exist */
+ res = remove_chain(dj.fs, dclst);
+ if (res)
+ goto out;
+ }
+
+ res = sync(dj.fs);
+
+out:
+ FREE_BUF();
+
+ return res;
+}
+
+/*
+ * Create a Directory
+ */
+int f_mkdir (
+ FATFS *fatfs,
+ const TCHAR *path /* Pointer to the directory path */
+)
+{
+ int res;
+ FF_DIR dj;
+ BYTE *dir, n;
+ DWORD dsc, dcl, pcl, tim = get_fattime();
+ DEF_NAMEBUF;
+
+ dj.fs = fatfs;
+
+ INIT_BUF(dj);
+ res = follow_path(&dj, path); /* Follow the file path */
+ if (res == 0) {
+ res = -EEXIST; /* Any object with same name is already existing */
+ goto out;
+ }
+
+ if (res != -ENOENT)
+ goto out;
+
+ dcl = create_chain(dj.fs, 0); /* Allocate a cluster for the new directory table */
+ if (dcl == 0) {
+ res = -ENOSPC; /* No space to allocate a new cluster */
+ goto out;
+ }
+ if (dcl == 1) {
+ res = -ERESTARTSYS;
+ goto out;
+ }
+
+ if (dcl == 0xFFFFFFFF) {
+ res = -EIO;
+ goto out;
+ }
+
+ /* Flush FAT */
+ res = move_window(dj.fs, 0);
+ if (res)
+ goto out;
+
+ /* Initialize the new directory table */
+ dsc = clust2sect(dj.fs, dcl);
+ dir = dj.fs->win;
+ memset(dir, 0, SS(dj.fs));
+ memset(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);
+ memcpy(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 != 0)
+ goto out;
+ memset(dir, 0, SS(dj.fs));
+ }
+
+ res = dir_register(&dj); /* Register the object to the directoy */
+ if (res) {
+ remove_chain(dj.fs, dcl); /* Could not register, remove cluster chain */
+ goto out;
+ }
+
+ 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);
+
+out:
+ FREE_BUF();
+
+ return res;
+}
+
+/*
+ * Change Attribute
+ */
+int f_chmod (
+ FATFS *fatfs,
+ const TCHAR *path, /* Pointer to the file path */
+ BYTE value, /* Attribute bits */
+ BYTE mask /* Attribute mask to change */
+)
+{
+ int res;
+ FF_DIR dj;
+ BYTE *dir;
+ DEF_NAMEBUF;
+
+ dj.fs = fatfs;
+
+ INIT_BUF(dj);
+ res = follow_path(&dj, path); /* Follow the file path */
+ FREE_BUF();
+ if (res == 0 && (dj.fn[NS] & NS_DOT))
+ res = -ENOENT;
+ if (res == 0) {
+ dir = dj.dir;
+ if (!dir) { /* Is it a root directory? */
+ res = -EINVAL;
+ } 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);
+ }
+ }
+
+ return res;
+}
+
+/*
+ * Change Timestamp
+ */
+int f_utime (
+ FATFS *fatfs,
+ const TCHAR *path, /* Pointer to the file/directory name */
+ const FILINFO *fno /* Pointer to the time stamp to be set */
+)
+{
+ int res;
+ FF_DIR dj;
+ BYTE *dir;
+ DEF_NAMEBUF;
+
+ dj.fs = fatfs;
+
+ INIT_BUF(dj);
+ res = follow_path(&dj, path); /* Follow the file path */
+ FREE_BUF();
+ if (res == 0 && (dj.fn[NS] & NS_DOT))
+ res = -ENOENT;
+ if (res == 0) {
+ dir = dj.dir;
+ if (!dir) { /* Root directory */
+ res = -EINVAL;
+ } 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);
+ }
+ }
+
+ return res;
+}
+
+/*
+ * Rename File/Directory
+ */
+int f_rename (
+ FATFS *fatfs,
+ const TCHAR *path_old, /* Pointer to the old name */
+ const TCHAR *path_new /* Pointer to the new name */
+)
+{
+ int res;
+ FF_DIR djo, djn;
+ BYTE buf[21], *dir;
+ DWORD dw;
+ DEF_NAMEBUF;
+
+ djo.fs = fatfs;
+
+ djn.fs = djo.fs;
+ INIT_BUF(djo);
+ res = follow_path(&djo, path_old); /* Check old object */
+ if (res == 0 && (djo.fn[NS] & NS_DOT)) {
+ res = -EINVAL;
+ goto out;
+ }
+
+ if (res)
+ goto out;
+
+ /* Old object is found */
+ if (!djo.dir) { /* Is root dir? */
+ res = -EINVAL;
+ goto out;
+ }
+
+ memcpy(buf, djo.dir+DIR_Attr, 21); /* Save the object information except for name */
+ memcpy(&djn, &djo, sizeof(FF_DIR)); /* Check new object */
+ res = follow_path(&djn, path_new);
+ if (res == 0) {
+ res = -EEXIST; /* The new object name is already existing */
+ goto out;
+ }
+
+ if (res != -ENOENT)
+ goto out;
+
+ /* It ia a valid path and no name collision */
+
+ res = dir_register(&djn); /* Register the new entry */
+ if (res)
+ goto out;
+
+ dir = djn.dir; /* Copy object information except for name */
+ memcpy(dir+13, buf+2, 19);
+ dir[DIR_Attr] = buf[0] | AM_ARC;
+ djo.fs->wflag = 1;
+ /* Update .. entry in the directory if needed */
+ if (djo.sclust != djn.sclust && (dir[DIR_Attr] & AM_DIR)) {
+ dw = clust2sect(djn.fs, LD_CLUST(dir));
+ if (!dw) {
+ res = -ERESTARTSYS;
+ goto out;
+ }
+
+ res = move_window(djn.fs, dw);
+ if (res)
+ goto out;
+ dir = djn.fs->win+SZ_DIR; /* .. entry */
+ if (dir[1] == '.') {
+ dw = (djn.fs->fs_type == FS_FAT32 && djn.sclust == djn.fs->dirbase) ? 0 : djn.sclust;
+ ST_CLUST(dir, dw);
+ djn.fs->wflag = 1;
+ }
+ }
+
+ res = dir_remove(&djo); /* Remove old entry */
+ if (res)
+ goto out;
+
+ res = sync(djo.fs);
+
+out:
+ FREE_BUF();
+
+ return res;
+}
+#endif /* CONFIG_FS_FAT_WRITE */
diff --git a/fs/fat/ff.h b/fs/fat/ff.h
new file mode 100644
index 0000000..e86ca3a
--- /dev/null
+++ b/fs/fat/ff.h
@@ -0,0 +1,239 @@
+/*---------------------------------------------------------------------------/
+/ FatFs - FAT file system module include file R0.08b (C)ChaN, 2011
+/----------------------------------------------------------------------------/
+/ 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) 2011, 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 product UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/----------------------------------------------------------------------------*/
+
+#ifndef _FATFS
+#define _FATFS 8237 /* Revision ID */
+
+#include <asm/unaligned.h>
+#include <linux/list.h>
+
+#include "integer.h" /* Basic integer types */
+#include "ffconf.h" /* FatFs configuration options */
+
+#if _FATFS != _FFCONF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+/* Type of path name strings on FatFs API */
+
+#if _LFN_UNICODE /* Unicode string */
+#ifndef CONFIG_FS_FAT_LFN
+#error _LFN_UNICODE must be 0 in non-LFN cfg.
+#endif
+#ifndef _INC_TCHAR
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#endif
+
+#else /* ANSI/OEM string */
+#ifndef _INC_TCHAR
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#endif
+
+#endif
+
+
+
+/* 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 n_rootdir; /* Number of root directory entries (FAT12/16) */
+#if _MAX_SS != 512
+ WORD ssize; /* Bytes per sector (512,1024,2048,4096) */
+#endif
+#ifdef CONFIG_FS_FAT_WRITE
+ DWORD last_clust; /* Last allocated cluster */
+ DWORD free_clust; /* Number of free clusters */
+ DWORD fsi_sector; /* fsinfo sector (FAT32) */
+#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) */
+ void *userdata; /* User data, ff core does not touch this */
+ struct list_head dirtylist;
+} FATFS;
+
+
+
+/* File object structure (FIL) */
+
+typedef struct {
+ FATFS* fs; /* Pointer to the owner file system object */
+ BYTE flag; /* File status flags */
+ BYTE pad1;
+ DWORD fptr; /* File read/write pointer (0 on file open) */
+ DWORD fsize; /* File size */
+ DWORD sclust; /* File start cluster (0 when fsize==0) */
+ DWORD clust; /* Current cluster */
+ DWORD dsect; /* Current data sector */
+#ifdef CONFIG_FS_FAT_WRITE
+ DWORD dir_sect; /* Sector containing the directory entry */
+ BYTE* dir_ptr; /* Ponter to the directory entry in the window */
+#endif
+#if _USE_FASTSEEK
+ DWORD* cltbl; /* Pointer to the cluster link map table (null on file open) */
+#endif
+#if _FS_SHARE
+ UINT lockid; /* File lock ID (index of file semaphore table) */
+#endif
+#if !_FS_TINY
+ BYTE buf[_MAX_SS]; /* File data read/write buffer */
+#endif
+} FIL;
+
+
+
+/* Directory object structure (DIR) */
+
+typedef struct {
+ FATFS* fs; /* Pointer to the owner file system object */
+ 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]} */
+#ifdef CONFIG_FS_FAT_LFN
+ WCHAR* lfn; /* Pointer to the LFN working buffer */
+ WORD lfn_idx; /* Last matched LFN index number (0xFFFF:No LFN) */
+#endif
+} FF_DIR;
+
+
+
+/* File status 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) */
+#ifdef CONFIG_FS_FAT_LFN
+ TCHAR* lfname; /* Pointer to the LFN buffer */
+ UINT lfsize; /* Size of LFN buffer in TCHAR */
+#endif
+} FILINFO;
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface */
+
+int f_mount (FATFS*); /* Mount/Unmount a logical drive */
+int f_open (FATFS*, FIL*, const TCHAR*, BYTE); /* Open or create a file */
+int f_read (FIL*, void*, UINT, UINT*); /* Read data from a file */
+int f_lseek (FIL*, DWORD); /* Move file pointer of a file object */
+int f_close (FIL*); /* Close an open file object */
+int f_opendir (FATFS*, FF_DIR*, const TCHAR*); /* Open an existing directory */
+int f_readdir (FF_DIR*, FILINFO*); /* Read a directory item */
+int f_stat (FATFS*, const TCHAR*, FILINFO*); /* Get file status */
+int f_write (FIL*, const void*, UINT, UINT*); /* Write data to a file */
+int f_getfree (FATFS*, const TCHAR*, DWORD*); /* Get number of free clusters on the drive */
+int f_truncate (FIL*); /* Truncate file */
+int f_sync (FIL*); /* Flush cached data of a writing file */
+int f_unlink (FATFS*, const TCHAR*); /* Delete an existing file or directory */
+int f_mkdir (FATFS*, const TCHAR*); /* Create a new directory */
+int f_chmod (FATFS*, const TCHAR*, BYTE, BYTE); /* Change attriburte of the file/dir */
+int f_utime (FATFS*, const TCHAR*, const FILINFO*); /* Change timestamp of the file/dir */
+int f_rename (FATFS*, const TCHAR*, const TCHAR*); /* Rename/Move a file or directory */
+int f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*); /* Forward data to the stream */
+int f_mkfs (BYTE, BYTE, UINT); /* Create a file system on the drive */
+int f_chdrive (BYTE); /* Change current drive */
+int f_chdir (const TCHAR*); /* Change current directory */
+int f_getcwd (TCHAR*, UINT); /* Get current directory */
+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 */
+
+#ifndef EOF
+#define EOF (-1)
+#endif
+
+#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
+#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
+#define f_tell(fp) ((fp)->fptr)
+#define f_size(fp) ((fp)->fsize)
+
+/*--------------------------------------------------------------*/
+/* Additional user defined functions */
+
+/* RTC function */
+DWORD get_fattime (void);
+
+/* Unicode support functions */
+WCHAR ff_convert (WCHAR, UINT); /* OEM-Unicode bidirectional conversion */
+WCHAR ff_wtoupper (WCHAR); /* Unicode upper-case conversion */
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address */
+
+
+/* File access control and file status flags (FIL.flag) */
+
+#define FA_READ 0x01
+#define FA_OPEN_EXISTING 0x00
+#define FA__ERROR 0x80
+
+#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
+
+/* 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 */
+
+
+/* Fast seek function */
+#define CREATE_LINKMAP 0xFFFFFFFF
+
+/* Multi-byte word access macros */
+
+#define LD_WORD(ptr) get_unaligned_le16(ptr)
+#define LD_DWORD(ptr) get_unaligned_le32(ptr)
+#define ST_WORD(ptr,val) put_unaligned_le16(val, ptr)
+#define ST_DWORD(ptr,val) put_unaligned_le32(val, ptr)
+
+#endif /* _FATFS */
diff --git a/fs/fat/ffconf.h b/fs/fat/ffconf.h
new file mode 100644
index 0000000..2f6a6c1
--- /dev/null
+++ b/fs/fat/ffconf.h
@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------/
+/ FatFs - FAT file system module configuration file R0.08b (C)ChaN, 2011
+/----------------------------------------------------------------------------/
+/
+/ CAUTION! Do not forget to make clean the project after any changes to
+/ the configuration options.
+/
+/----------------------------------------------------------------------------*/
+#ifndef _FFCONF
+#define _FFCONF 8237 /* Revision ID */
+
+
+/*---------------------------------------------------------------------------/
+/ Function 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 _USE_STRFUNC 0 /* 0:Disable or 1/2:Enable */
+/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+
+
+#define _USE_MKFS 0 /* 0:Disable or 1:Enable */
+/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */
+
+
+#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_FASTSEEK 0 /* 0:Disable or 1:Enable */
+/* To enable fast seek feature, set _USE_FASTSEEK to 1. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/----------------------------------------------------------------------------*/
+
+#define _CODE_PAGE 932
+/* The _CODE_PAGE 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.)
+*/
+
+#define _MAX_LFN 255 /* Maximum LFN length to handle (12 to 255) */
+
+#define ff_memalloc xzalloc
+#define ff_memfree free
+/* The _USE_LFN option switches the LFN support.
+/
+/ 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.
+/ 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. */
+
+
+#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. */
+
+/*---------------------------------------------------------------------------/
+/ Physical Drive Configurations
+/----------------------------------------------------------------------------*/
+
+#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 _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. */
+
+
+
+/*---------------------------------------------------------------------------/
+/ 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.
+/
+/ 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. */
+
+
+/* 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_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.. */
+
+#define _FS_SHARE 0 /* 0:Disable or >=1:Enable */
+/* To enable file shareing feature, set _FS_SHARE to 1 or greater. The value
+ defines how many files can be opened simultaneously. */
+
+
+#endif /* _FFCONFIG */
diff --git a/fs/fat/integer.h b/fs/fat/integer.h
new file mode 100644
index 0000000..04956aa
--- /dev/null
+++ b/fs/fat/integer.h
@@ -0,0 +1,28 @@
+/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef _INTEGER
+#define _INTEGER
+
+/* 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;
+
+/* 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 32-bit integer */
+typedef long LONG;
+typedef unsigned long ULONG;
+typedef unsigned long DWORD;
+
+#endif
--
1.7.2.3
More information about the barebox
mailing list