import RT-Thread RTOS 0.3.x to Google SVN

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2 bbd45198-f89e-11dd-88c7-29a3b14d5316

53 files changed, 9005 insertions, 0 deletions

diff --git a/filesystem/dfs/config.mk b/filesystem/dfs/config.mk
new file mode 100644
index 0000000000..9a8de66a52
--- /dev/null
+++ b/filesystem/dfs/config.mk
@@ -0,0 +1,40 @@
+#+------------------------------------------------------------------------------
+#|        Device FileSystem                                           
+#+------------------------------------------------------------------------------
+#|        Copyright 2004, 2005  www.fayfayspace.org.                  
+#|        All rights reserved.                                        
+#+------------------------------------------------------------------------------
+#| File      : config.mk, the configuration of makefile               
+#+------------------------------------------------------------------------------
+#| Chang Logs:                                                        
+#| Date           Author       notes                                  
+#| 2005-01-22     ffxz         The first version.                     
+#+------------------------------------------------------------------------------
+
+KERNEL_ROOT=$(DFS_ROOT_DIR)/../..
+include $(KERNEL_ROOT)/config.mk
+
+CFLAGS	+=-I$(KERNEL_ROOT)/include -I$(DFS_ROOT_DIR)/include -I.
+
+# Source and objects
+DFS_SRC	= $(DFS_ROOT_DIR)/src/dfs_fs.c $(DFS_ROOT_DIR)/src/dfs_init.c \
+	$(DFS_ROOT_DIR)/src/dfs_util.c $(DFS_ROOT_DIR)/src/dfs_raw.c \
+	$(DFS_ROOT_DIR)/src/dfs_api.c $(DFS_ROOT_DIR)/src/dfs_task.c \
+	$(DFS_ROOT_DIR)/src/dfs_cache.c
+
+ifneq ($(RT_USING_NEWLIB), 1)
+DFS_SRC += $(DFS_ROOT_DIR)/src/dfs_posix.c
+endif
+
+DFS_OBJS= $(DFS_SRC:.c=.o)
+
+FAT_SRC	= $(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_init.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_mount.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_fat.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_misc.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_file.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_cache.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_filename.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_direntry.c \
+	$(DFS_ROOT_DIR)/filesystems/fatfs/fatfs_mkfs.c
+FAT_OBJS	= $(FAT_SRC:.c=.o)
diff --git a/filesystem/dfs/dfs_config.h b/filesystem/dfs/dfs_config.h
new file mode 100644
index 0000000000..378030f742
--- /dev/null
+++ b/filesystem/dfs/dfs_config.h
@@ -0,0 +1,100 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_opts.h, the option definitions of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-01-22     ffxz         The first version.

++------------------------------------------------------------------------------

+*/

+

+#ifndef __DFS_CONFIG_H__

+#define __DFS_CONFIG_H__

+

+/*

++------------------------------------------------------------------------------

+| Device Manager options

++------------------------------------------------------------------------------

+*/

+/* Device Options parameters */

+#define DEVICES_MAX		8

+#define DEVICE_NAME_MAX	8

+

+/*

++------------------------------------------------------------------------------

+| Device Filesystem options

++------------------------------------------------------------------------------

+*/

+/* the max length of filesystem name */

+#define DFS_FS_NAME_MAX				4

+/* the max type of filesystem */

+#define DFS_FILESYSTEM_TYPES_MAX	2

+

+/* the max length of path name */

+#define DFS_PATH_MAX		256

+/* the max length of file name */

+#define DFS_FILE_MAX		256

+

+/* options for server task */

+#define DFS_MBOX_NUMBER		32

+#define DFS_SERVER_STACK	1024

+#define DFS_SERVER_PRI		110

+#define DFS_SERVER_SLICE	20

+

+/*

++------------------------------------------------------------------------------

+| FAT filesystem options

++------------------------------------------------------------------------------

+*/

+/* file name max length */

+#define FAT_NAME_MAX	256

+/* max number of FAT filesystem */

+#define FATFS_MAX		2

+

+/* the size of sector */

+#define SECTOR_SIZE		512

+

+/* FAT table sector cache options */

+#define FAT_CACHE_SIZE          0x10        /* config parameter */

+#define FAT_CACHE_MASK          (FAT_CACHE_SIZE-1)

+

+#define GET16(x)    (*(x)) | (*((x)+1) << 8)

+#define GET32(x)    (*(x)) | (*((x)+1) << 8) | (*((x)+2) << 16) | (*((x)+3) << 24)

+

+#define SET16(x, v)             	\

+    do                          	\

+    {                           	\

+        *(x)     = (v) & 0x00ff; 	\

+        (*((x)+1)) = (v) >> 8;     	\

+    } while ( 0 )

+

+#define SET32(x, v)                         	\

+    do                                      	\

+    {                                       	\

+        *(x)     = (v)  & 0x000000ff;        	\

+        (*((x)+1)) = ((v) >> 8) & 0x000000ff;  	\

+        (*((x)+2)) = ((v) >> 16) & 0x000000ff; 	\

+        (*((x)+3)) = ((v) >> 24);              	\

+    } while ( 0 )

+

+#define DFS_DEBUG_INFO			0x01

+#define DFS_DEBUG_WARNING		0x02

+#define DFS_DEBUG_ERROR			0x04

+

+#define DFS_DEBUG_LEVEL			(DFS_DEBUG_INFO | DFS_DEBUG_WARNING | DFS_DEBUG_ERROR)

+

+/* #define DFS_DEBUG */

+#ifdef DFS_DEBUG

+#define dfs_log(level, x)		do { if (level & DFS_DEBUG_LEVEL) 	\

+	{rt_kprintf("DFS %s, %d:", __FILE__, __LINE__); rt_kprintf x;	\

+	rt_kprintf ("\n");}}while (0)

+#else

+#define dfs_log(level, x)

+#endif

+

+#endif

diff --git a/filesystem/dfs/filesystems/efsl/CHANGELOG b/filesystem/dfs/filesystems/efsl/CHANGELOG
new file mode 100644
index 0000000000..94f188c3d9
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/CHANGELOG
@@ -0,0 +1,39 @@
+CHANGEFILE
+----------
+
+This is the Changefile for the development 0.3 branch of EFSL.
+Recording began with EFSL-0.3.3
+
+0.3.5
+-----
+* Added warning in documentation that it is outdated
+* Changed structure definitions
+* Implemnted full-feature cp
+* Renamed some efsl-functions (all starting with EFSL_)
+* Added another example for AVR.
+* Updated docs on getting started on AVR.
+
+0.3.4
+-----
+* Fixed avr support
+* Created new avr example + makefile
+* Some more work on new fsutils
+
+0.3.3
+-----
+
+* Renamed src/core to src/base
+* Implemented new hwInterface structure
+  Support for multiple hwEndpoints in one project
+* Modified SD_SPI to work as a general protocol
+* Modified Linuxfile to the new hwInterface model
+* Created a new efs_configger, now supports every
+  combination of partitions/disc
+* Implemented full support for little and big endian
+  machines, as well as for little and big endian 
+  filesystems
+* Created new build system, for multiple platforms,
+  configurable from one file
+* Changes cpo to use the new library functions
+* Broke both dsp & atmega support
+
diff --git a/filesystem/dfs/filesystems/efsl/VERSION b/filesystem/dfs/filesystems/efsl/VERSION
new file mode 100644
index 0000000000..dc6910364f
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/VERSION
@@ -0,0 +1,3 @@
+efsl-0.3.6

+

+[Embedded Filesystems Library]

diff --git a/filesystem/dfs/filesystems/efsl/src/base/debug.c b/filesystem/dfs/filesystems/efsl/src/base/debug.c
new file mode 100644
index 0000000000..05962c6178
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/debug.c
@@ -0,0 +1,182 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : debug.c                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are used for debugging output on different    *
+*               environments                                                  *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/* COMMENT REGARDING FUNCTION COMMENTS IN THIS FILE
+ * Only the linuxfile debug functions are commented since all functions
+ * perform the same logical task.
+*/
+
+/*****************************************************************************/
+#include "debug.h"
+/*****************************************************************************/
+
+
+/*****************************************************************************/
+#ifdef DEBUG
+#ifdef HW_ENDPOINT_LINUX_ALL
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void debug(const eint8 *format, ...)
+ * Description: This function prints debug output to the screen (target dependant)
+ * and if DO_FUNC_DEBUG is defined also to a localfile.
+ * Return value: void
+*/
+
+void debug(const eint8 *format, ...)
+{
+	va_list ap;
+	#ifdef DO_FUNC_DEBUG
+	euint8 c;
+	extern  FILE* debugfile;
+	extern volatile euint8 tw;
+	#endif
+	
+	va_start(ap, format);
+	vprintf(format,ap);
+	#ifdef DO_FUNC_DEBUG
+		for(c=0;c<tw+1;c++)
+		{
+			fprintf(debugfile,"  ");
+		}
+		vfprintf(debugfile,format,ap);
+	#endif
+	va_end(ap);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void debug_funcin(const eint8 *format, ...)
+ * Description: This function marks the entrance of a function, which
+ * increments a tabfieldcounter. A tree like structure can the be found in the
+ * debugging file.
+ * Return value: void
+*/
+
+void debug_funcin(const eint8 *format, ...)
+{
+	#ifdef DO_FUNC_DEBUG
+	eint8 c;
+	va_list ap;
+	extern  FILE* debugfile;
+	extern volatile unsigned char tw;
+	
+	if(debugfile==RT_NULL)return;
+	
+	for(c=0;c<tw;c++){
+		fprintf(debugfile,"  ");
+	}
+	
+	va_start(ap, format);
+	vfprintf(debugfile,format,ap);
+	va_end(ap);
+	fprintf(debugfile,"\n");
+	
+	tw++;
+	#endif
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void debug_funcout(const eint8 *format, ...)
+ * Description: Decrements the tabfieldcounter. This function is called everywhere
+ * a function is left.
+ * Return value: void
+*/
+
+void debug_funcout(const eint8 *format, ...)
+{
+	#ifdef DO_FUNC_DEBUG
+	eint8 c;
+	va_list ap;
+	extern  FILE* debugfile;
+	extern volatile euint8 tw;
+	
+	if(debugfile==RT_NULL)return;
+	
+	if(tw>0)tw--;
+	
+	for(c=0;c<tw;c++){
+		fprintf(debugfile,"  ");
+	}
+	
+	va_start(ap, format);
+	vfprintf(debugfile,format,ap);
+	va_end(ap);
+	fprintf(debugfile,"\n");
+	#endif
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void debug_init()
+ * Description: This function optionally opens the debugfile, or does any other
+ * initialisation to enable debugoutput.
+ * Return value: void
+*/
+void debug_init()
+{
+	#ifdef DO_FUNC_DEBUG
+	extern  FILE* debugfile;
+	extern volatile unsigned char tw;
+
+	debugfile=RT_NULL;
+	tw=0;
+	
+	debugfile=fopen("DBG.OUT","w");
+	#endif
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void debug_end()
+ * Description: This function closes the debugfile.
+ * Return value: void
+*/
+void debug_end()
+{
+	#ifdef DO_FUNC_DEBUG
+	extern  FILE* debugfile;
+	
+	fflush(debugfile);
+	fclose(debugfile);
+	#endif
+}
+/*****************************************************************************/
+
+/*****************************************************************************/
+#endif
+#endif
+/*****************************************************************************/
+
diff --git a/filesystem/dfs/filesystems/efsl/src/base/efs.c b/filesystem/dfs/filesystems/efsl/src/base/efs.c
new file mode 100644
index 0000000000..2ac98abb55
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/efs.c
@@ -0,0 +1,489 @@
+ /*
+ * File      : efs.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006, 2007, RT-Thread Develop Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://openlab.rt-thread.com/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2008-08-16     Yi.Qiu		The first version.
+ */
+ 
+#include "efs.h"
+#include "ls.h"
+#include "ui.h"
+#include "fat.h"
+#include <string.h>

+
+#define EFS_MAX		2
+
+struct dfs_filesystem_operation efs;
+
+/**
+ * This function will initialize efsl to DFS interface.
+ * 

+ * @return 0 on succesful
+ */
+int efsl_init()
+{
+	/* init EFS filesystem operations */
+	efs.name[0] = 'e';
+	efs.name[1] = 'f';
+	efs.name[2] = 's';
+	efs.name[3]	= '\0';
+
+	efs.mount 	= efs_mount;
+	efs.unmount = efs_unmount;
+	efs.open 	= efs_open;
+	efs.close 	= efs_close;
+	efs.ioctl 	= efs_ioctl;
+	efs.read 	= efs_read;
+	efs.write 	= efs_write;
+	efs.lseek 	= efs_lseek;
+	efs.getdents= efs_getdents;
+	efs.unlink 	= efs_unlink;
+	efs.stat 	= efs_stat;
+	efs.rename 	= efs_rename;
+
+	/* register EFS file system */
+	dfs_register(&efs);
+
+	return 0;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_mount(struct dfs_filesystem* fs)
+{
+	efsl_fs* efsfs;
+	int result;
+
+	/* allocate an EFS filesystem entry */

+	efsfs = (efsl_fs*) rt_malloc (sizeof(efsl_fs));

+
+	/* init efs filesystem struct */
+	efsfs->partition.ioman = rt_malloc(sizeof(IOManager));
+	efsfs->partition.ioman->device = fs->dev_id;
+
+	part_initPartition(&efsfs->partition);
+	ioman_init(efsfs->partition.ioman);
+	result = fs_initFs(&efsfs->filesystem ,&efsfs->partition);

+
+	/* set to DFS filesystem user data */
+	fs->data = efsfs;
+	
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_unmount(struct dfs_filesystem* fs)
+{
+	efsl_fs* efsfs;
+
+	efsfs = (efsl_fs*) fs->data;
+	if ( efsfs == RT_NULL ) return -DFS_STATUS_EINVAL;
+
+	fs_flushFs(&efsfs->filesystem);
+	rt_free(efsfs->partition.ioman);

+	rt_free(efsfs);
+
+	fs->data = RT_NULL;
+
+	return 0;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_open(struct dfs_fd* file)
+{
+	File* efsfile;
+	DirList* efsdir;
+	efsl_fs* efsfs = (efsl_fs*)(file->fs->data);
+	int result = 0;
+	
+	/* parameter check */
+	if ( file == RT_NULL || file->fs == RT_NULL || 
+		file->fs->data == RT_NULL ) 
+	{	
+		dfs_log(DFS_DEBUG_INFO, ("Invalid argument"));		
+		return -DFS_STATUS_EINVAL;
+	}
+
+	/* open directory */
+	if(file->flags & DFS_O_DIRECTORY)
+	{
+		/* write directory is not supported */
+		if(file->flags & DFS_O_WRONLY || file->flags & DFS_O_RDWR)
+		{
+			dfs_log(DFS_DEBUG_INFO, ("write directory isn't supported"));			
+			return -DFS_STATUS_EISDIR;
+		}
+		
+		/* create directory */
+		if(file->flags & DFS_O_CREAT)
+		{
+			dfs_log(DFS_DEBUG_INFO, ("create directory"));
+			result = mk_dir(&efsfs->filesystem, file->path);
+			if(result < 0) 
+			{
+				dfs_log(DFS_DEBUG_INFO, ("directory %s has existed", file->path));
+				return -DFS_STATUS_EEXIST;
+			}	
+		}
+		
+		efsdir = (DirList*)rt_malloc(sizeof(DirList));
+		if(efsdir == RT_NULL) 
+		{
+			dfs_log(DFS_DEBUG_INFO, ("memory alloc failed"));
+			return -DFS_STATUS_ENOMEM;		
+		}
+		
+		result = ls_openDir(efsdir, &efsfs->filesystem, file->path);
+		if(result < 0)
+		{
+			dfs_log(DFS_DEBUG_INFO, ("open directory %s failed", file->path));
+			rt_free(efsdir);
+		}	
+		else 
+		{
+			file->data = efsdir;
+		}	
+	}
+	/* open file */
+	else
+	{
+		efsfile = (File *)rt_malloc(sizeof(File));
+		if (efsfile == RT_NULL) 
+		{
+			dfs_log(DFS_DEBUG_INFO, ("memory alloc failed"));			
+			return -DFS_STATUS_ENOMEM;		
+		}
+
+		result = file_fopen(efsfile, &efsfs->filesystem, file->path, file->flags);
+		if(result < 0)	
+		{	
+			dfs_log(DFS_DEBUG_INFO, ("open file %s failed", file->path));
+			rt_free(efsfile);
+		}	
+		else
+		{
+			file->pos  = efsfile->FilePtr;
+			file->size = efsfile->FileSize;
+			file->data = efsfile;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_close(struct dfs_fd* file)
+{
+	int result = 0;
+	
+	if (!file || !(file->flags & DFS_F_OPEN)) return -DFS_STATUS_EBADF;

+	
+	if(!(file->flags & DFS_F_DIRECTORY)) 
+		result = file_fclose((File *)file->data);
+	else

+	{

+		dfs_log(DFS_DEBUG_INFO, ("close a directory, %s", file->path));
+	}

+
+	dfs_log(DFS_DEBUG_INFO, ("close a file, %s", file->path));
+
+	/* free directory or file */
+	rt_free(file->data);

+	file->data = RT_NULL;
+
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_ioctl(struct dfs_fd* file, int cmd, void* args)
+{
+	return 0;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_read(struct dfs_fd* file, void* buf, rt_size_t len)
+{
+	File* efsfile = file->data;
+	int result = 0;
+
+	/* parameter check */

+	RT_ASSERT(efsfile != RT_NULL);

+	
+	result = file_read(efsfile, len, buf);
+	file->pos = efsfile->FilePtr;
+
+	dfs_log(DFS_DEBUG_INFO, ("read file %s %d bytes", file->path, result));
+	
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_write(struct dfs_fd* file, const void* buf, rt_size_t len)
+{
+	File* efsfile = file->data;
+	int result = 0;
+
+	/* parameter check */

+	RT_ASSERT(efsfile != RT_NULL);

+	
+	result = file_write(efsfile, len, (euint8 *)buf);
+	file->pos = efsfile->FilePtr;
+	file->size = efsfile->FileSize;
+
+	dfs_log(DFS_DEBUG_INFO, ("write file %s %d bytes", file->path, result));
+	
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_lseek(struct dfs_fd* file, rt_off_t offset)
+{
+	int result = 0;
+	DirList* efsdir;
+	efsl_fs* efsfs = (efsl_fs *)file->fs->data;

+
+	/* parameter check */

+	RT_ASSERT(efsfs   != RT_NULL);
+
+	/* seek directory */
+	if(file->flags & DFS_O_DIRECTORY)
+	{
+		efsdir = (DirList*)file->data;
+		
+		/* only support offset equels zero */
+		if(offset == 0)
+		{
+			result = ls_openDir(efsdir, &efsfs->filesystem, file->path);
+			if(result < 0)
+			{
+				dfs_log(DFS_DEBUG_INFO, ("open directory %s failed", file->path));
+			}		
+		}
+		/* should implement in future version */
+		else
+		{
+			dfs_log(DFS_DEBUG_INFO, ("not implement"));
+		}
+	}
+	/* seek file */
+	else
+	{
+		File* efsfile = file->data;
+		
+		/* parameter check */
+		if ( efsfile == RT_NULL) return -DFS_STATUS_EBADF;
+
+		result = file_setpos(efsfile, offset);
+	}
+	
+	return result;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_getdents(struct dfs_fd* file, struct dfs_dirent* dirp, rt_uint32_t count)
+{
+	DirList* efsdir = (DirList*)file->data;
+	struct dfs_dirent* d;
+	int result = 0;
+
+	/* fd check */
+	if ( efsdir == RT_NULL) return -DFS_STATUS_EBADF;
+
+	/* flags check */
+	if(!(file->flags & DFS_F_DIRECTORY)) return -DFS_STATUS_EBADF;
+
+	/* make integer count */
+	count = (count / sizeof(struct dfs_dirent)) * sizeof(struct dfs_dirent);
+	if ( count == 0 ) return -DFS_STATUS_EINVAL;
+
+	while(1)
+	{
+		/* it's the end of file */
+		if(ls_getNext(efsdir) < 0) return 0;
+
+		d = dirp + result;
+    		/* copy dirent name */
+		fat_ShortnameToString(efsdir->currentEntry.FileName, d->d_name);
+		d->d_reclen = (euint16)sizeof(struct dfs_dirent);	
+
+		/* set type */
+		d->d_type = DFS_DT_UNKNOWN;
+		if (efsdir->currentEntry.Attribute & ATTR_DIRECTORY ) d->d_type &= DFS_DT_DIR;
+		else d->d_type &= DFS_DT_REG;
+
+		result ++;
+
+		/* is it enough? */
+		if ( result * sizeof(struct dfs_dirent) >= count )

+			break;
+	}
+
+	return result * sizeof(struct dfs_dirent);
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_unlink(struct dfs_filesystem* fs, const char* path)
+{
+	efsl_fs* efsfs;

+
+	RT_ASSERT(fs   != RT_NULL);

+	efsfs = (efsl_fs *)fs->data;

+
+	RT_ASSERT(path  != RT_NULL);

+	RT_ASSERT(efsfs != RT_NULL);

+	
+	return un_link(&efsfs->filesystem, (euint8 *)path);
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_stat(struct dfs_filesystem* fs, const char *path, struct dfs_stat *st)
+{
+	FileRecord entry;
+	FileLocation loc;
+	efsl_fs* efsfs = (efsl_fs*)(fs->data);
+
+	/* parameter check */

+	RT_ASSERT(efsfs != RT_NULL);
+	
+	/* file does not exist */
+	if(fs_findFile(&efsfs->filesystem, (char *)path, &loc, 0) == 0)
+	{
+		dfs_log(DFS_DEBUG_ERROR, ("can't find direntry"));		
+		return -DFS_STATUS_ENOENT;
+	}
+
+	dir_getFileStructure(&efsfs->filesystem, &entry, &loc);
+
+	st->st_dev = fs->dev_id;
+	st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | 
+	DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
+	if ( entry.Attribute & ATTR_DIRECTORY )
+	{
+		st->st_mode &= ~DFS_S_IFREG;
+		st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
+	}
+	if ( entry.Attribute & ATTR_READ_ONLY )
+		st->st_mode &= ~(DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH);
+
+	st->st_size  = entry.FileSize;
+	st->st_mtime = entry.WriteTime;
+	
+	return 0;
+}
+
+/**
+ * This function will set a hook function, which will be invoked when a memory 
+ * block is allocated from heap memory.
+ * 
+ * @param hook the hook function
+ */
+int efs_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath)
+{
+	FileRecord old_entry, new_entry;
+	FileLocation old_loc, new_loc;
+	efsl_fs* efsfs;
+	eint8 fatfilename[11];
+	
+	efsfs = (efsl_fs*) fs->data ;
+	RT_ASSERT(efsfs != RT_NULL);

+
+	dir_getFatFileName((eint8 *)newpath, &fatfilename[0]);	
+	
+	/* parameters check */
+	if (strlen(oldpath) > DFS_PATH_MAX || 
+		strlen(newpath) > DFS_PATH_MAX ||
+		/* old path is a directory that contains newpath */
+		strncmp(oldpath, newpath, strlen(newpath)) == 0) 
+		{
+			dfs_log(DFS_DEBUG_ERROR, ("old path is a directory that contains newpath"));					
+			return -DFS_STATUS_EINVAL;
+		}	
+
+	/* if can't find old direntry */
+	if(fs_findFile(&efsfs->filesystem, (eint8 *)oldpath, &old_loc, 0) == 0)
+	{
+		dfs_log(DFS_DEBUG_ERROR, ("can't find old direntry"));		
+		return -DFS_STATUS_ENOENT;
+	}
+	dir_getFileStructure(&efsfs->filesystem, &old_entry, &old_loc);
+
+	/* if the new direntry exist */
+	if(fs_findFile(&efsfs->filesystem, (eint8 *)newpath, &new_loc, 0) > 0)
+	{
+		dfs_log(DFS_DEBUG_ERROR, ("new direntry existed"));
+		return -DFS_STATUS_ENOENT;
+	}
+	if(fs_findFreeFile(&efsfs->filesystem, (eint8 *)newpath, &new_loc, 0))
+	{
+		memCpy(&old_entry, &new_entry, sizeof(FileRecord));	
+		memCpy(fatfilename, new_entry.FileName, 11);
+		dir_createDirectoryEntry(&efsfs->filesystem, &new_entry, &new_loc);
+	}
+
+	/* delete the old direntry */
+	old_entry.FileName[0] = 0xe5;
+	dir_updateDirectoryEntry(&efsfs->filesystem, &old_entry, &old_loc);	
+
+	return 0;
+}
diff --git a/filesystem/dfs/filesystems/efsl/src/base/extract.c b/filesystem/dfs/filesystems/efsl/src/base/extract.c
new file mode 100644
index 0000000000..7b4b77336b
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/extract.c
@@ -0,0 +1,57 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : extract.c                                                        *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions to copy structures that get      *
+*               corrupted when using direct memory copy                       *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "extract.h"
+/*****************************************************************************/
+
+#if !(defined(BYTE_ALIGNMENT))
+#warning "Compiling f_setbxx"
+void ex_setb16(euint8* buf,euint16 data)
+{
+	buf[1] = data>>8;
+	buf[0] = data>>0;
+}
+
+void ex_setb32(euint8* buf,euint32 data)
+{
+	buf[3] = data>>24;
+	buf[2] = data>>16;
+	buf[1] = data>>8;
+	buf[0] = data>>0;
+}
+#endif
+
+
+
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/debug.h b/filesystem/dfs/filesystems/efsl/src/base/include/debug.h
new file mode 100644
index 0000000000..505e0466a6
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/debug.h
@@ -0,0 +1,68 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : debug.h                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are used for debugging output on different    *
+*               environments                                                  *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+/*****************************************************************************/
+#include "types.h"
+#include "config.h"
+/*****************************************************************************/
+
+#ifndef DEBUG
+	#define TXT(x) ;
+	#define DBG(x) ;
+	#define FUNC_IN(x) ;
+	#define FUNC_OUT(x) ;
+#endif
+
+#ifdef DEBUG
+
+	#ifdef HW_ENDPOINT_LINUX
+		#include <stdio.h>
+		#include <stdarg.h>
+	
+		#define TXT(x) x
+		#define DBG(x) debug x
+		#define FUNC_IN(x) debug_funcin(x)
+		#define FUNC_OUT(x) debug_funcout(x)
+	#endif
+
+	void debug(const eint8 *format, ...);
+	void debug_init();
+	void debug_end();
+
+#endif
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/efs.h b/filesystem/dfs/filesystems/efsl/src/base/include/efs.h
new file mode 100644
index 0000000000..3ab3d914f6
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/efs.h
@@ -0,0 +1,89 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : efs.c                                                            *
+* Release  : 0.3 - devel                                                      *
+* Description : This should become the wrapper around efs. It will contain    *
+*               functions like efs_init etc.                                  *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __EFS_H__
+#define __EFS_H__
+
+/*****************************************************************************/
+#include <dfs_fs.h>
+
+#include "types.h"
+#include "config.h"
+#include "extract.h"
+#include "partition.h"
+
+/* WARNING !!!!
+ * These includes DO NOT BELONG HERE,
+ * remove them when the VFS layer is implemented !!!!
+ */
+#include "fs.h"
+#include "file.h"
+#include "tm.h"
+#include "ui.h" 
+
+/*****************************************************************************/
+#define LINUX_FILE_CONFIG	0x00
+#define AVR_SD_CONFIG		0x01
+/*****************************************************************************/
+
+#define efs_read_sectors(device, start, count, buf)  rt_device_read(device,  \
+	(start) * SECTOR_SIZE, (buf), (count) * SECTOR_SIZE) / SECTOR_SIZE
+#define efs_write_sectors(device, start, count, buf) rt_device_write(device, \
+	(start) * SECTOR_SIZE, (buf), (count) * SECTOR_SIZE) / SECTOR_SIZE
+
+struct _efsl_fs {
+	Partition partition;
+	FileSystem filesystem;
+};
+typedef struct _efsl_fs efsl_fs;
+
+/* EFS filesystem file operations */
+int efs_mount(struct dfs_filesystem* fs);
+int efs_unmount(struct dfs_filesystem* fs);
+int efs_open(struct dfs_fd* file);
+int efs_close(struct dfs_fd* file);
+int efs_ioctl(struct dfs_fd* file, int cmd, void* args);
+int efs_read(struct dfs_fd* file, void* buf, rt_size_t len);
+int efs_write(struct dfs_fd* file, const void* buf, rt_size_t len);
+int efs_lseek(struct dfs_fd* file, rt_off_t offset);
+int efs_getdents(struct dfs_fd* file, struct dfs_dirent* dirp, rt_uint32_t count);
+int efs_unlink(struct dfs_filesystem* fs, const char* path);
+int efs_stat(struct dfs_filesystem* fs, const char *path, struct dfs_stat *st);
+int efs_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath);
+
+/*****************************************************************************/
+int efsl_init(void);
+
+#endif
+
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/extract.h b/filesystem/dfs/filesystems/efsl/src/base/include/extract.h
new file mode 100644
index 0000000000..4ae5212c5c
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/extract.h
@@ -0,0 +1,101 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : extract.h                                                        *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions to copy structures that get      *
+*               corrupted when using direct memory copy                       *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __EXTRACT_H_
+#define __EXTRACT_H_
+
+/*****************************************************************************/
+#include "config.h"
+#include "types.h"
+/*****************************************************************************/
+
+#if !(defined(HOST_LITTLE_ENDIAN)) && !(defined(HOST_BIG_ENDIAN))
+#error Endianess undefined, see config.h
+#elif defined(HOST_LITTLE_ENDIAN) && (defined(HOST_BIG_ENDIAN))
+#error Endianess defined as little and big, see config.h
+#endif
+
+/*****************************************************************************/
+
+#define end_conv16(x)  ((((euint16)(x) & 0xff00) >> 8) | \
+                      (((euint16)(x) & 0x00ff) << 8))
+#define end_conv32(x)  ((((euint32)(x) & 0xff000000) >> 24) | \
+                       (((euint32)(x) & 0x00ff0000) >> 8)  | \
+                       (((euint32)(x) & 0x0000ff00) << 8)  | \
+                       (((euint32)(x) & 0x000000ff) << 24))
+
+/*****************************************************************************/
+
+#if defined(BYTE_ALIGNMENT)
+	#define ex_getb16(buf) (*((euint16*)(buf)))
+	#define ex_setb16(buf,data) *((euint16*)(buf))=(data)
+	#define ex_getb32(buf) (*((euint32*)(buf)))
+	#define ex_setb32(buf,data) *((euint32*)(buf))=(data)
+#else
+	#define ex_getb16(buf) \
+		((euint16)(*((euint8*)(buf)+1)<<8) + \
+		 (euint16)(*((euint8*)(buf)+0)<<0))
+	void ex_setb16(euint8* buf,euint16 data);
+	#define ex_getb32(buf) \
+		((euint32)(*((euint8*)(buf)+3)<<24) + \
+		 (euint32)(*((euint8*)(buf)+2)<<16) + \
+		 (euint32)(*((euint8*)(buf)+1)<<8)  + \
+		 (euint32)(*((euint8*)(buf)+0)<<0))
+	void ex_setb32(euint8* buf,euint32 data);
+#endif
+
+#if defined(HOST_LITTLE_ENDIAN)
+	#define ex_lth16(buf) ex_getb16(buf)
+	#define ex_lth32(buf) ex_getb32(buf)
+	#define ex_bth16(buf) end_conv16(ex_getb16(buf))
+	#define ex_bth32(buf) end_conv32(ex_getb32(buf))
+	
+	#define ex_htl16(buf) ex_setb16(buf)
+	#define ex_htl32(buf) ex_setb32(buf)
+	#define ex_htb16(buf) ex_setb16(end_conv16(buf))
+	#define ex_htb32(buf) ex_setb32(end_conv32(buf))
+#elif defined(HOST_BIG_ENDIAN)
+	#define ex_lth16(buf) end_conv16(ex_getb16(buf))
+	#define ex_lth32(buf) end_conv32(ex_getb32(buf))
+	#define ex_bth16(buf) ex_getb16(buf)
+	#define ex_bth32(buf) ex_getb32(buf)
+	
+	#define ex_htl16(buf) ex_setb16(end_conv16(buf))
+	#define ex_htl32(buf) ex_setb32(end_conv32(buf))
+	#define ex_htb16(buf) ex_setb16(buf)
+	#define ex_htb32(buf) ex_setb32(buf)
+#endif
+
+#endif
+
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/ioman.h b/filesystem/dfs/filesystems/efsl/src/base/include/ioman.h
new file mode 100644
index 0000000000..406ed5aff3
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/ioman.h
@@ -0,0 +1,140 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ioman.c                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : The IO Manager receives all requests for sectors in a central *
+*               allowing it to make smart decision regarding caching.         *
+*               The IOMAN_NUMBUFFER parameter determines how many sectors     *
+*               ioman can cache. ioman also supports overallocating and       *
+*               backtracking sectors.                                         *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __IOMAN_H__
+#define __IOMAN_H__
+
+/*****************************************************************************/
+#include <rtthread.h>
+
+#include "error.h"
+#include "plibc.h"
+#include "debug.h"
+#include "types.h"
+#include "config.h"
+/*****************************************************************************/
+
+#define IOMAN_STATUS_ATTR_VALIDDATA  0
+#define IOMAN_STATUS_ATTR_USERBUFFER 1
+#define IOMAN_STATUS_ATTR_WRITE      2
+
+#define IOM_MODE_READONLY  1
+#define IOM_MODE_READWRITE 2
+#define IOM_MODE_EXP_REQ   4
+
+struct _IOManStack{
+	euint32 sector;
+	euint8  status;
+	euint8  usage;
+};
+typedef struct _IOManStack IOManStack;
+
+struct _IOManager{
+	rt_device_t device;
+	euint8 *bufptr;
+	euint16 numbuf;
+	euint16 numit;
+		
+	IOMAN_ERR_EUINT8
+		
+	IOManStack stack[IOMAN_NUMBUFFER][IOMAN_NUMITERATIONS];
+	
+	euint32 sector[IOMAN_NUMBUFFER];
+	euint8  status[IOMAN_NUMBUFFER];
+	euint8  usage[IOMAN_NUMBUFFER];
+	euint8  reference[IOMAN_NUMBUFFER];
+	euint8  itptr[IOMAN_NUMBUFFER];
+#ifdef IOMAN_DO_MEMALLOC
+	euint8  cache_mem[IOMAN_NUMBUFFER * 512];
+#endif
+};
+typedef struct _IOManager IOManager;
+
+#define IOBJ ioman
+
+#define ioman_isValid(bp) ioman_getAttr(IOBJ,bp,IOMAN_STATUS_ATTR_VALIDDATA)
+#define ioman_isUserBuf(bp) ioman_getAttr(IOBJ,bp,IOMAN_STATUS_ATTR_USERBUFFER)
+#define ioman_isWritable(bp) ioman_getAttr(IOBJ,bp,IOMAN_STATUS_ATTR_WRITE)
+
+#define ioman_setValid(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_VALIDDATA,1)
+#define ioman_setUserBuf(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_USERBUFFER,1)
+#define ioman_setWritable(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_WRITE,1)
+
+#define ioman_setNotValid(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_VALIDDATA,0)
+#define ioman_setNotUserBuf(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_USERBUFFER,0)
+#define ioman_setNotWritable(bp) ioman_setAttr(IOBJ,bp,IOMAN_STATUS_ATTR_WRITE,0)
+
+#define ioman_isReqRo(mode)  ((mode)&(IOM_MODE_READONLY))
+#define ioman_isReqRw(mode)  ((mode)&(IOM_MODE_READWRITE))
+#define ioman_isReqExp(mode) ((mode)&(IOM_MODE_EXP_REQ))
+
+esint8 ioman_init(IOManager *ioman, euint8* bufferarea);
+void ioman_reset(IOManager *ioman);
+euint8* ioman_getBuffer(IOManager *ioman,euint8* bufferarea);
+void ioman_setAttr(IOManager *ioman,euint16 bufplace,euint8 attribute,euint8 val);
+euint8 ioman_getAttr(IOManager *ioman,euint16 bufplace,euint8 attribute);
+euint8 ioman_getUseCnt(IOManager *ioman,euint16 bufplace);
+void ioman_incUseCnt(IOManager *ioman,euint16 bufplace);
+void ioman_decUseCnt(IOManager *ioman,euint16 bufplace);
+void ioman_resetUseCnt(IOManager *ioman,euint16 bufplace);
+euint8 ioman_getRefCnt(IOManager *ioman,euint16 bufplace);
+void ioman_incRefCnt(IOManager *ioman,euint16 bufplace);
+void ioman_decRefCnt(IOManager *ioman,euint16 bufplace);
+void ioman_resetRefCnt(IOManager *ioman,euint16 bufplace);
+esint8 ioman_pop(IOManager *ioman,euint16 bufplace);
+esint8 ioman_push(IOManager *ioman,euint16 bufplace);
+euint8* ioman_getPtr(IOManager *ioman,euint16 bufplace);
+esint16 ioman_getBp(IOManager *ioman,euint8* buf);
+esint8 ioman_readSector(IOManager *ioman,euint32 address,euint8* buf);
+esint8 ioman_writeSector(IOManager *ioman, euint32 address, euint8* buf);
+void ioman_resetCacheItem(IOManager *ioman,euint16 bufplace);
+esint32 ioman_findSectorInCache(IOManager *ioman, euint32 address);
+esint32 ioman_findFreeSpot(IOManager *ioman);
+esint32 ioman_findUnusedSpot(IOManager *ioman);
+esint32 ioman_findOverallocableSpot(IOManager *ioman);
+esint8 ioman_putSectorInCache(IOManager *ioman,euint32 address, euint16 bufplace);
+esint8 ioman_flushSector(IOManager *ioman, euint16 bufplace);
+euint8* ioman_getSector(IOManager *ioman,euint32 address, euint8 mode);
+esint8 ioman_releaseSector(IOManager *ioman,euint8* buf);
+esint8 ioman_directSectorRead(IOManager *ioman,euint32 address, euint8* buf);
+esint8 ioman_directSectorWrite(IOManager *ioman,euint32 address, euint8* buf);
+esint8 ioman_flushRange(IOManager *ioman,euint32 address_low, euint32 address_high);
+esint8 ioman_flushAll(IOManager *ioman);
+
+void ioman_printStatus(IOManager *ioman);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/ioman_small.h b/filesystem/dfs/filesystems/efsl/src/base/include/ioman_small.h
new file mode 100644
index 0000000000..5962f56c6e
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/ioman_small.h
@@ -0,0 +1,93 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ioman_small.c                                                    *
+* Release  : 0.3 - devel                                                      *
+* Description : The IO Manager receives all requests for sectors in a central *
+*               allowing it to make smart decision regarding caching.         *
+*               The IOMAN_NUMBUFFER parameter determines how many sectors     *
+*               ioman can cache. ioman also supports overallocating and       *
+*               backtracking sectors.                                         *
+*               This is the small version of IOMan, for systems with limited  *
+*               resources. It features only one fixed buffer, and has         *
+*               simplified operation                                          *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#include "error.h"
+#include "plibc.h"
+#include "debug.h"
+#include "types.h"
+#include "config.h"
+
+#define IOMAN_STATUS_ATTR_VALIDDATA  0
+#define IOMAN_STATUS_ATTR_USERBUFFER 1
+#define IOMAN_STATUS_ATTR_WRITE      2
+
+#define IOM_MODE_READONLY  1
+#define IOM_MODE_READWRITE 2
+#define IOM_MODE_EXP_REQ   4
+
+struct _IOManStack{
+	euint32 sector;
+	euint8  status;
+};
+typedef struct _IOManStack IOManStack;
+
+struct _IOManager{
+	rt_device_t  device;					/* device handler */	
+	euint8 bufptr[512];
+	IOMAN_ERR_EUINT8
+	euint32 sector;
+	euint8  status;
+	euint8  itptr;
+	IOManStack stack;
+};
+typedef struct _IOManager IOManager;
+
+#define IOBJ ioman
+
+#define ioman_isValid() ioman_getAttr(IOBJ,IOMAN_STATUS_ATTR_VALIDDATA)
+#define ioman_isUserBuf() ioman_getAttr(IOBJ,IOMAN_STATUS_ATTR_USERBUFFER)
+#define ioman_isWritable() ioman_getAttr(IOBJ,IOMAN_STATUS_ATTR_WRITE)
+
+#define ioman_setValid() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_VALIDDATA,1)
+#define ioman_setUserBuf() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_USERBUFFER,1)
+#define ioman_setWritable() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_WRITE,1)
+
+#define ioman_setNotValid() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_VALIDDATA,0)
+#define ioman_setNotUserBuf() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_USERBUFFER,0)
+#define ioman_setNotWritable() ioman_setAttr(IOBJ,IOMAN_STATUS_ATTR_WRITE,0)
+
+#define ioman_isReqRo(mode)  ((mode)&(IOM_MODE_READONLY))
+#define ioman_isReqRw(mode)  ((mode)&(IOM_MODE_READWRITE))
+#define ioman_isReqExp(mode) ((mode)&(IOM_MODE_EXP_REQ))
+
+esint8 ioman_init(IOManager *ioman, euint8* bufferarea);
+void ioman_reset(IOManager *ioman);
+void ioman_setAttr(IOManager *ioman,euint8 attribute,euint8 val);
+euint8 ioman_getAttr(IOManager *ioman,euint8 attribute);
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/partition.h b/filesystem/dfs/filesystems/efsl/src/base/include/partition.h
new file mode 100644
index 0000000000..07118b658a
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/partition.h
@@ -0,0 +1,73 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : partition.c                                                      *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are partition specific. Searching FAT type    *
+*               partitions and read/write functions to partitions.            *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __PARTITION_H__
+#define __PARTITION_H__
+
+/*****************************************************************************/
+#include "config.h"
+#include "error.h"
+#include "types.h"
+// #include "ioman.h"

+#include <dfs_cache.h>
+/*****************************************************************************/
+
+#define PT_FAT12  		0x01
+#define PT_FAT16A 		0x04
+#define PT_FAT16  		0x06
+#define PT_FAT32  		0x0B
+#define PT_FAT32A 		0x5C
+#define PT_FAT16B 		0x5E
+
+struct _Partition{
+	IOManager *ioman;
+};
+typedef struct _Partition Partition;
+
+void part_initPartition(Partition *part);
+eint16 part_isFatPart(euint8 type);
+esint8 part_readBuf(Partition *part, euint32 address, euint8* buf);
+esint8 part_readPartBuf(Partition *part, euint32 address, euint8* buf, euint32 offset, euint16 len);
+eint16 part_writeBuf(Partition *part,euint32 address,euint8* buf);
+euint8* part_getSect(Partition *part, euint32 address,euint8 mode);
+esint8 part_relSect(Partition *part, euint8* buf);
+
+esint8 part_flushPart(Partition *part,euint32 addr_l, euint32 addr_h);
+
+esint8 part_directSectorRead(Partition *part, euint32 address, euint8* buf, euint32 numsector);
+esint8 part_directSectorWrite(Partition *part, euint32 address, euint8* buf, euint32 numsector);
+
+#include "extract.h"
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/base/include/plibc.h b/filesystem/dfs/filesystems/efsl/src/base/include/plibc.h
new file mode 100644
index 0000000000..30d86bd60b
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/include/plibc.h
@@ -0,0 +1,49 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : plibc.c                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains replacements of common c library functions *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __PLIBC_H__
+#define __PLIBC_H__
+
+/*****************************************************************************/
+#include "debug.h"
+#include "types.h"
+#include "config.h"
+/*****************************************************************************/
+
+euint16 strMatch(eint8* bufa, eint8*bufb,euint32 n);
+void memCpy(void* psrc, void* pdest, euint32 size);
+void memClr(void *pdest,euint32 size);
+void memSet(void *pdest,euint32 size,euint8 data);
+
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/base/ioman.c b/filesystem/dfs/filesystems/efsl/src/base/ioman.c
new file mode 100644
index 0000000000..42fb664324
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/ioman.c
@@ -0,0 +1,600 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ioman.c                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : The IO Manager receives all requests for sectors in a central *
+*               allowing it to make smart decision regarding caching.         *
+*               The IOMAN_NUMBUFFER parameter determines how many sectors     *
+*               ioman can cache. ioman also supports overallocating and       *
+*               backtracking sectors.                                         *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "ioman.h"
+#include "efs.h"
+/*****************************************************************************/
+
+esint8 ioman_init(IOManager *ioman,  euint8* bufferarea)
+{
+	ioman->bufptr = ioman_getBuffer(ioman,bufferarea);
+	ioman->numbuf = IOMAN_NUMBUFFER;
+	ioman->numit  = IOMAN_NUMITERATIONS;
+
+	ioman_reset(ioman);
+	return(0);
+}
+/*****************************************************************************/
+
+void ioman_reset(IOManager *ioman)
+{
+	euint16 nb,ni;
+
+	memClr(ioman->sector,sizeof(euint32)*ioman->numbuf);
+	memClr(ioman->status,sizeof(euint8) *ioman->numbuf);
+	memClr(ioman->usage ,sizeof(euint8) *ioman->numbuf);
+	memClr(ioman->itptr ,sizeof(euint8) *ioman->numbuf);
+	ioman_setError(ioman,IOMAN_NOERROR);
+
+	for(nb=0;nb<ioman->numbuf;nb++){
+		for(ni=0;ni<ioman->numit;ni++){
+			ioman->stack[nb][ni].sector=0;
+			ioman->stack[nb][ni].status=0;
+			ioman->stack[nb][ni].usage =0;
+		}
+	}
+}
+/*****************************************************************************/
+
+euint8* ioman_getBuffer(IOManager *ioman,euint8* bufferarea)
+{
+#ifdef IOMAN_DO_MEMALLOC
+	return(ioman->cache_mem);
+#else
+	return(bufferarea);
+#endif
+}
+/*****************************************************************************/
+
+void ioman_setAttr(IOManager *ioman,euint16 bufplace,euint8 attribute,euint8 val)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_SETATTROUTOFBOUNDS);
+		return; /* Out of bounds */
+	}
+
+	if(val){
+		ioman->status[bufplace]|=1<<attribute;
+	}else{
+		ioman->status[bufplace]&=~(1<<attribute);
+	}
+}
+/*****************************************************************************/
+
+euint8 ioman_getAttr(IOManager *ioman,euint16 bufplace,euint8 attribute)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_GETATTROUTOFBOUNDS);
+		return(0xFF); /* Out of bounds */
+	}
+
+	return(ioman->status[bufplace]&(1<<attribute));
+}
+/*****************************************************************************/
+
+euint8 ioman_getUseCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return(0x00);
+	}
+	return(ioman->usage[bufplace]);
+}
+/*****************************************************************************/
+
+
+void ioman_incUseCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	if(ioman->usage[bufplace]==0xFF)return;
+	else ioman->usage[bufplace]++;
+}
+/*****************************************************************************/
+
+void ioman_decUseCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	if(ioman->usage[bufplace]==0x0)return;
+	else ioman->usage[bufplace]--;
+}
+/*****************************************************************************/
+
+void ioman_resetUseCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	ioman->usage[bufplace]=0x00;
+}
+/*****************************************************************************/
+
+euint8 ioman_getRefCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return(0x00);
+	}
+	return(ioman->reference[bufplace]);
+}
+/*****************************************************************************/
+
+void ioman_incRefCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	if(ioman->reference[bufplace]==0xFF)return;
+	else ioman->reference[bufplace]++;
+}
+/*****************************************************************************/
+
+void ioman_decRefCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	if(ioman->reference[bufplace]==0x00)return;
+	else ioman->reference[bufplace]--;
+}
+/*****************************************************************************/
+
+void ioman_resetRefCnt(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	ioman->reference[bufplace]=0x00;
+}
+/*****************************************************************************/
+
+esint8 ioman_pop(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_POPEMPTYSTACK);
+		return(-1);
+	}
+	if(ioman->itptr[bufplace]==0 || ioman->itptr[bufplace]>IOMAN_NUMITERATIONS)return(-1);
+	ioman->itptr[bufplace]--;
+	ioman->sector[bufplace] = ioman->stack[bufplace][ioman->itptr[bufplace]].sector;
+	ioman->status[bufplace] = ioman->stack[bufplace][ioman->itptr[bufplace]].status;
+	ioman->usage[bufplace]  = ioman->stack[bufplace][ioman->itptr[bufplace]].usage;
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_push(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return(-1);
+	}
+	if(ioman->itptr[bufplace]>=IOMAN_NUMITERATIONS){
+		ioman_setError(ioman,IOMAN_ERR_PUSHBEYONDSTACK);
+		return(-1);
+	}
+	ioman->stack[bufplace][ioman->itptr[bufplace]].sector = ioman->sector[bufplace];
+	ioman->stack[bufplace][ioman->itptr[bufplace]].status = ioman->status[bufplace];
+	ioman->stack[bufplace][ioman->itptr[bufplace]].usage  = ioman->usage[bufplace];
+	ioman->itptr[bufplace]++;
+	return(0);
+}
+/*****************************************************************************/
+
+euint8* ioman_getPtr(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return(0);
+	}
+	return(ioman->bufptr+bufplace*512);
+}
+/*****************************************************************************/
+
+esint16 ioman_getBp(IOManager *ioman,euint8* buf)
+{
+	if(buf<(ioman->bufptr) || buf>=( ioman->bufptr+(ioman->numbuf*512) )){
+		ioman_setError(ioman,IOMAN_ERR_CACHEPTROUTOFRANGE);
+		return(-1);
+	}
+	return((buf-(ioman->bufptr))/512);
+}
+/*****************************************************************************/
+
+esint8 ioman_readSector(IOManager *ioman,euint32 address,euint8* buf)
+{
+	esint8 r;
+
+	if(buf==0){
+		return(-1);
+	}
+
+	r = efs_read_sectors(ioman->device, address, 1, buf);
+
+	if(r!=1){
+		ioman_setError(ioman,IOMAN_ERR_READFAIL);
+		return(-1);
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_writeSector(IOManager *ioman, euint32 address, euint8* buf)
+{
+	esint8 r;
+
+	if(buf==0)return(-1);
+
+	r = efs_write_sectors(ioman->device, address, 1, buf);
+
+	if(r!=1){
+		ioman_setError(ioman,IOMAN_ERR_WRITEFAIL);
+		return(-1);
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+void ioman_resetCacheItem(IOManager *ioman,euint16 bufplace)
+{
+	if(bufplace>=ioman->numbuf){
+		ioman_setError(ioman,IOMAN_ERR_OPOUTOFBOUNDS);
+		return;
+	}
+	ioman->sector[bufplace]    = 0;
+	ioman->status[bufplace]    = 0;
+	ioman->usage[bufplace]     = 0;
+	ioman->reference[bufplace] = 0;
+}
+/*****************************************************************************/
+
+esint32 ioman_findSectorInCache(IOManager *ioman, euint32 address)
+{
+	euint16 c;
+
+	for(c=0;c<ioman->numbuf;c++){
+		if(ioman_isValid(c) && ioman->sector[c] == address)return(c);
+	}
+	return(-1);
+}
+/*****************************************************************************/
+
+esint32 ioman_findFreeSpot(IOManager *ioman)
+{
+	euint16 c;
+
+	for(c=0;c<ioman->numbuf;c++){
+		if(!ioman_isValid(c))return(c);
+	}
+	return(-1);
+}
+/*****************************************************************************/
+
+esint32 ioman_findUnusedSpot(IOManager *ioman)
+{
+	esint32 r=-1;
+	euint16 c;
+	euint8 fr=0,lr=0xFF;
+
+	for(c=0;c<ioman->numbuf;c++){
+		if(ioman_getUseCnt(ioman,c)==0){
+			if(!ioman_isWritable(c) && !fr){
+				fr=1;
+				lr=0xFF;
+				r=-1;
+			}
+			if(ioman_isWritable(c) && !fr){
+				if(ioman_getRefCnt(ioman,c)<=lr){
+					r=c;
+					lr=ioman_getRefCnt(ioman,c);
+				}
+			}
+			if(fr && !ioman_isWritable(c)){
+				if(ioman_getRefCnt(ioman,c)<=lr){
+					r=c;
+					lr=ioman_getRefCnt(ioman,c);
+				}
+			}
+		}
+	}
+	return(r);
+}
+/*****************************************************************************/
+
+esint32 ioman_findOverallocableSpot(IOManager *ioman)
+{
+	euint8 points,lp=0xFF;
+	euint16 c;
+	esint32 r=-1;
+
+	for(c=0;c<ioman->numbuf;c++){
+		if(ioman->itptr[c]<ioman->numit){
+			points = 0;
+			if(ioman_isWritable(c))points+=0x7F;
+			points += ((euint16)(ioman->itptr[c]*0x4D))/(ioman->numit);
+			points += ((euint16)(ioman_getRefCnt(ioman,c)*0x33))/0xFF;
+			if(points<lp){
+				lp=points;
+				r=c;
+			}
+		}
+	}
+	return(r);
+}
+/*****************************************************************************/
+
+esint8 ioman_putSectorInCache(IOManager *ioman, euint32 address, euint16 bufplace)
+{
+	euint8* buf;
+
+	if((buf = ioman_getPtr(ioman,bufplace))==0){
+		ioman_setError(ioman,IOMAN_ERR_CACHEPTROUTOFRANGE);
+		return(-1);
+	}
+	if((ioman_readSector(ioman,address,buf))){
+		ioman_setError(ioman,IOMAN_ERR_READFAIL);
+		return(-1);
+	}
+	ioman_setValid(bufplace);
+	ioman->sector[bufplace]=address;
+	return(0);
+}
+/*****************	if(bufplace>=ioman->numbuf)return;
+************************************************************/
+
+esint8 ioman_flushSector(IOManager *ioman, euint16 bufplace)
+{
+	euint8* buf;
+
+	if((buf = ioman_getPtr(ioman,bufplace))==0){
+		ioman_setError(ioman,IOMAN_ERR_CACHEPTROUTOFRANGE);
+		return(-1);
+	}
+	if(!ioman_isWritable(bufplace)){
+		ioman_setError(ioman,IOMAN_ERR_WRITEREADONLYSECTOR);
+		return(-1);
+	}
+	if(ioman_writeSector(ioman,ioman->sector[bufplace],buf)){ /* ERROR HERE STILL TO BE FIXED -> ! must be removed! */
+		ioman_setError(ioman,IOMAN_ERR_WRITEFAIL);
+		return(-1);
+	}
+	if(ioman->usage[bufplace]==0)ioman_setNotWritable(bufplace);
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_flushRange(IOManager *ioman,euint32 address_low, euint32 address_high)
+{
+	euint32 c;
+
+	if(address_low>address_high){
+		c=address_low; address_low=address_high;address_high=c;
+	}
+
+	for(c=0;c<ioman->numbuf;c++){
+		if((ioman->sector[c]>=address_low) && (ioman->sector[c]<=address_high) && (ioman_isWritable(c))){
+			if(ioman_flushSector(ioman,c)){
+				return(-1);
+			}
+			if(ioman->usage[c]==0)ioman_setNotWritable(c);
+		}
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_flushAll(IOManager *ioman)
+{
+	euint16 c;
+
+	for(c=0;c<ioman->numbuf;c++){
+		if(ioman_isWritable(c)){
+			if(ioman_flushSector(ioman,c)){
+				return(-1);
+			}
+			if(ioman->usage[c]==0)ioman_setNotWritable(c);
+		}
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+euint8* ioman_getSector(IOManager *ioman,euint32 address, euint8 mode)
+{
+	esint32 bp;
+
+	if((bp=ioman_findSectorInCache(ioman,address))!=-1){
+		if(ioman_isReqRw(mode)){
+			ioman_setWritable(bp);
+		}
+		ioman_incUseCnt(ioman,bp);
+		if(!ioman_isReqExp(mode))ioman_incRefCnt(ioman,bp);
+		return(ioman_getPtr(ioman,bp));
+	}
+
+	if((bp=ioman_findFreeSpot(ioman))==-1){
+		if(((bp=ioman_findUnusedSpot(ioman))!=-1)&&(ioman_isWritable(bp))){
+			ioman_flushSector(ioman,bp);
+		}
+	}
+
+	if(bp!=-1){
+		ioman_resetCacheItem(ioman,bp);
+		if((ioman_putSectorInCache(ioman,address,bp))){
+			return(0);
+		}
+		if(ioman_isReqRw(mode)){
+			ioman_setWritable(bp);
+		}
+		ioman_incUseCnt(ioman,bp);
+		if(!ioman_isReqExp(mode))ioman_incRefCnt(ioman,bp);
+		return(ioman_getPtr(ioman,bp));
+	}
+
+	if((bp=ioman_findOverallocableSpot(ioman))!=-1){
+		if(ioman_isWritable(bp)){
+			ioman_flushSector(ioman,bp);
+		}
+		if(ioman_push(ioman,bp)){
+			return(0);
+		}
+		ioman_resetCacheItem(ioman,bp);
+		if((ioman_putSectorInCache(ioman,address,bp))){
+			return(0);
+		}
+		if(ioman_isReqRw(mode)){
+			ioman_setWritable(bp);
+		}
+		ioman_incUseCnt(ioman,bp);
+		if(!ioman_isReqExp(mode))ioman_incRefCnt(ioman,bp);
+		return(ioman_getPtr(ioman,bp));
+	}
+	ioman_setError(ioman,IOMAN_ERR_NOMEMORY);
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_releaseSector(IOManager *ioman,euint8* buf)
+{
+	euint16 bp;
+
+	bp=ioman_getBp(ioman,buf);
+	ioman_decUseCnt(ioman,bp);
+
+	if(ioman_getUseCnt(ioman,bp)==0)
+	{
+		if(ioman_isWritable(bp))
+		{
+			ioman_flushSector(ioman,bp);
+		}
+		if(ioman->itptr[bp]!=0)
+		{
+			ioman_pop(ioman,bp);
+			ioman_putSectorInCache(ioman,ioman->sector[bp],bp);
+		}
+	}
+
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_directSectorRead(IOManager *ioman,euint32 address, euint8* buf)
+{
+	euint8* ibuf;
+	esint16 bp;
+
+	if((bp=ioman_findSectorInCache(ioman,address))!=-1){
+		ibuf=ioman_getPtr(ioman,bp);
+		memCpy(ibuf,buf,512);
+		return(0);
+	}
+
+	if((bp=ioman_findFreeSpot(ioman))!=-1){
+		if((ioman_putSectorInCache(ioman,address,bp))){
+			return(-1);
+		}
+		ibuf=ioman_getPtr(ioman,bp);
+		memCpy(ibuf,buf,512);
+		return(0);
+	}
+
+	if(ioman_readSector(ioman,address,buf)){
+		return(-1);
+	}
+
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_directSectorWrite(IOManager *ioman,euint32 address, euint8* buf)
+{
+	euint8* ibuf;
+	esint16 bp;
+
+	if((bp=ioman_findSectorInCache(ioman,address))!=-1){
+		ibuf=ioman_getPtr(ioman,bp);
+		memCpy(buf,ibuf,512);
+		ioman_setWritable(bp);
+		return(0);
+	}
+
+	if((bp=ioman_findFreeSpot(ioman))!=-1){
+		ibuf=ioman_getPtr(ioman,bp);
+		memCpy(buf,ibuf,512);
+		ioman_resetCacheItem(ioman,bp);
+		ioman->sector[bp]=address;
+		ioman_setWritable(bp);
+		ioman_setValid(bp);
+		return(0);
+	}
+
+	if(ioman_writeSector(ioman,address,buf)){
+		return(-1);
+	}
+
+	return(0);
+}
+/*****************************************************************************/
+
+void ioman_printStatus(IOManager *ioman)
+{
+	euint16 c;
+
+	DBG((TXT("IO-Manager -- Report\n====================\n")));
+	DBG((TXT("Buffer is %i sectors, from %p to %p\n"),
+	          ioman->numbuf,ioman->bufptr,ioman->bufptr+(ioman->numbuf*512)));
+	for(c=0;c<ioman->numbuf;c++){
+		if(ioman_isValid(c)){
+			DBG((TXT("BP %3i\t SC %8li\t\t US %i\t RF %i\t %s %s\n"),
+				c,ioman->sector[c],ioman_getUseCnt(ioman,c),ioman_getRefCnt(ioman,c),
+				ioman_isUserBuf(c) ? "USRBUF" : "      ",
+				ioman_isWritable(c) ? "WRITABLE" : "READONLY"));
+		}
+	}
+}
+/*****************************************************************************/
+
diff --git a/filesystem/dfs/filesystems/efsl/src/base/ioman_small.c b/filesystem/dfs/filesystems/efsl/src/base/ioman_small.c
new file mode 100644
index 0000000000..287e0e08a4
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/ioman_small.c
@@ -0,0 +1,120 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ioman_small.c                                                    *
+* Release  : 0.3 - devel                                                      *
+* Description : The IO Manager receives all requests for sectors in a central *
+*               allowing it to make smart decision regarding caching.         *
+*               The IOMAN_NUMBUFFER parameter determines how many sectors     *
+*               ioman can cache. ioman also supports overallocating and       *
+*               backtracking sectors.                                         *
+*               This is the small version of IOMan, for systems with limited  *
+*               resources. It features only one fixed buffer, and has         *
+*               simplified operation                                          *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#include "ioman_small.h"
+
+esint8 ioman_init(IOManager *ioman, euint8* bufferarea)
+{
+	ioman_reset(ioman);
+	return(0);
+}
+/*****************************************************************************/
+
+void ioman_reset(IOManager *ioman)
+{
+	ioman->sector=ioman->status=ioman->itptr=0;
+	ioman->stack.sector=ioman->stack.status=0;
+		
+	ioman_setError(ioman,IOMAN_NOERROR);
+		
+}
+/*****************************************************************************/
+
+void ioman_setAttr(IOManager *ioman,euint8 attribute,euint8 val)
+{
+	if(val){
+		ioman->status|=1<<attribute;
+	}else{
+		ioman->status&=~(1<<attribute);
+	}
+}
+/*****************************************************************************/
+
+euint8 ioman_getAttr(IOManager *ioman,euint8 attribute)
+{
+	return(ioman->status&(1<<attribute));
+}
+/*****************************************************************************/
+
+
+euint8* ioman_getSector(IOManager *ioman,euint32 address, euint8 mode)
+{
+	if(address==ioman->sector){
+		if(mode==IOM_MODE_READWRITE)ioman_setWritable();
+		return(ioman->bufptr);
+	}
+	
+}
+
+esint8 ioman_readSector(IOManager *ioman,euint32 address,euint8* buf)
+{
+	esint8 r;
+
+	if(buf==0){
+		return(-1);
+	}
+	
+	//r=if_readBuf(ioman->iface,address,buf);
+	r = efs_read_sectors(ioman->device, address, 1, buf);
+	
+	if(r!=0){
+		ioman_setError(ioman,IOMAN_ERR_READFAIL);
+		return(-1);
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ioman_writeSector(IOManager *ioman, euint32 address, euint8* buf)
+{
+	esint8 r;
+
+	if(buf==0)return(-1);
+	
+	//r=if_writeBuf(ioman->iface,address,buf);
+	r = efs_write_sectors(ioman->device, address, 1, buf);
+	
+	if(r<=0){
+		ioman_setError(ioman,IOMAN_ERR_WRITEFAIL);
+		return(-1);
+	}
+	return(0);
+}
+/*****************************************************************************/
diff --git a/filesystem/dfs/filesystems/efsl/src/base/partition.c b/filesystem/dfs/filesystems/efsl/src/base/partition.c
new file mode 100644
index 0000000000..7aa67c99c1
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/partition.c
@@ -0,0 +1,125 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : partition.c                                                      *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are partition specific. Searching FAT type    *
+*               partitions and read/write functions to partitions.            *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "partition.h"
+#include "efs.h"
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void part_initPartition(Partition *part,Disc* refDisc)
+ * Description: This function searches the 4 partitions for a FAT class partition
+ * and marks the first one found as the active to be used partition.
+*/
+void part_initPartition(Partition *part)
+{	
+	part_setError(part,PART_NOERROR);
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * eint16 part_isFatPart(euint8 type)
+ * Description: This functions checks if a partitiontype (eint8) is of the FAT
+ * type in the broadest sense. I
+ * Return value: If it is FAT, returns 1, otherwise 0.
+*/
+eint16 part_isFatPart(euint8 type)
+{
+	if(type == PT_FAT12  ||
+	   type == PT_FAT16A ||
+	   type == PT_FAT16  ||
+	   type == PT_FAT32  ||
+	   type == PT_FAT32A ||
+	   type == PT_FAT16B   )
+	{
+		return(1);
+	}
+	return(0);
+}
+/*****************************************************************************/ 
+
+esint8 part_readBuf(Partition *part, euint32 address, euint8* buf)
+{
+	return efs_read_sectors(part->ioman->device, address, 1, buf);
+}
+
+/* ****************************************************************************  
+ * eint16 part_writeBuf(Partition *part,euint32 address,euint8* buf)
+ * Description: This function writes 512 bytes, from buf. It's offset is address
+ * sectors from the beginning of the partition.
+ * Return value: It returns whatever the hardware function returns. (-1=error)
+*/
+eint16 part_writeBuf(Partition *part,euint32 address,euint8* buf)
+{
+	/*DBG((TXT("part_writeBuf :: %li\n"),address));*/
+	return efs_write_sectors(part->ioman->device, address, 1, buf);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * euint8* part_getSect(Partition *part, euint32 address, euint8 mode)
+ * Description: This function calls ioman_getSector, but recalculates the sector
+ * address to be partition relative.
+ * Return value: Whatever getSector returns. (pointer or 0)
+*/
+euint8* part_getSect(Partition *part, euint32 address, euint8 mode)
+{
+	return(ioman_getSector(part->ioman,address,mode));
+}
+
+/* ****************************************************************************  
+ * esint8 part_relSect(Partition *part, euint8* buf)
+ * Description: This function calls ioman_releaseSector.
+ * Return value: Whatever releaseSector returns.
+*/
+esint8 part_relSect(Partition *part, euint8* buf)
+{
+	return(ioman_releaseSector(part->ioman,buf));
+}
+
+esint8 part_flushPart(Partition *part,euint32 addr_l, euint32 addr_h)
+{
+	return ioman_flushRange(part->ioman,addr_l,addr_h);
+}
+
+esint8 part_directSectorRead(Partition *part, euint32 address, euint8* buf, euint32 numsector)
+{
+	return ioman_directSectorRead(part->ioman, address, buf, numsector);
+}
+
+esint8 part_directSectorWrite(Partition *part,euint32 address, euint8* buf, euint32 numsector)
+{
+	return ioman_directSectorWrite(part->ioman, address, buf, numsector);
+}
diff --git a/filesystem/dfs/filesystems/efsl/src/base/plibc.c b/filesystem/dfs/filesystems/efsl/src/base/plibc.c
new file mode 100644
index 0000000000..ee2c923846
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/base/plibc.c
@@ -0,0 +1,83 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : plibc.c                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains replacements of common c library functions *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "plibc.h"
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * unsigned short strMatch(char* bufa, char*bufb, unsigned long n)
+ * Description: Compares bufa and bufb for a length of n bytes.
+ * Return value: Returns the number of character NOT matching.
+*/
+euint16 strMatch(eint8* bufa, eint8*bufb,euint32 n)
+{
+	euint32 c;
+	euint16 res=0;
+	for(c=0;c<n;c++)if(bufa[c]!=bufb[c])res++;
+	return(res);
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * void memCpy(void* psrc, void* pdest, unsigned long size)
+ * Description: Copies the contents of psrc into pdest on a byte per byte basis.
+ * The total number of bytes copies is size.
+*/
+void memCpy(void* psrc, void* pdest, euint32 size)
+{
+	while(size>0){
+		*((eint8*)pdest+size-1)=*((eint8*)psrc+size-1);
+		size--;
+	}
+}
+/*****************************************************************************/ 
+
+void memClr(void *pdest,euint32 size)
+{
+	while(size>0){
+		*(((eint8*)pdest)+size-1)=0x00;
+		size--;
+	}
+}
+
+void memSet(void *pdest,euint32 size,euint8 data)
+{
+	while(size>0){
+		*(((eint8*)pdest)+size-1)=data;
+		size--;
+	}
+}
+
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/dir.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/dir.c
new file mode 100644
index 0000000000..4cf13ca4a0
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/dir.c
@@ -0,0 +1,365 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : dir.c                                                            *
+* Release  : 0.3 - devel                                                      *
+* Description : The functions of dir.c are part of fs.c, they deal with all   *
+*               the directory specific stuff.                                 *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "dir.h"
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void dir_getFileStructure(FileSystem *fs,FileRecord *filerec,FileLocation *loc)
+ * Description: This function stores the filerecord located at loc in filerec.
+ * It fetches the required sector for this.
+ * Return value: void
+*/
+void dir_getFileStructure(FileSystem *fs,FileRecord *filerec,FileLocation *loc)
+{
+	euint8 *buf;
+
+	buf=part_getSect(fs->part,loc->Sector,IOM_MODE_READONLY);
+	*filerec=*(((FileRecord*)buf)+loc->Offset);
+	part_relSect(fs->part,buf);
+}	
+
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void dir_createDirectoryEntry(FileSystem *fs,FileRecord *filerec,FileLocation *loc)
+ * Description: This function writes the filerecord stored in filerec to disc at
+ * location loc. 
+ * Return value: void
+*/
+void dir_createDirectoryEntry(FileSystem *fs,FileRecord *filerec,FileLocation *loc)
+{
+	euint8 *buf;
+	
+	buf = part_getSect(fs->part,loc->Sector,IOM_MODE_READWRITE);
+	memCpy(filerec,buf+(loc->Offset*sizeof(*filerec)),sizeof(*filerec));
+	part_relSect(fs->part,buf);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void dir_createDefaultEntry(FileSystem *fs,FileRecord *filerec,eint8* fatfilename)
+ * Description: This function fills in a filerecord with safe default values, and
+ * a given fatfilename. If your system has a means of knowing time, here is an 
+ * excellent place to apply it to the filerecord.  
+ * Return value: void
+*/
+void dir_createDefaultEntry(FileSystem *fs,FileRecord *filerec,eint8* fatfilename)
+{
+	memCpy(fatfilename,filerec->FileName,11);
+	filerec->Attribute=0x00;
+	filerec->NTReserved=0x00;
+	filerec->MilliSecTimeStamp=0x00;
+	filerec->CreatedTime=time_getTime();
+	filerec->CreatedDate=time_getDate(); 
+	filerec->AccessDate=filerec->CreatedDate;
+	filerec->FirstClusterHigh=0x0000;
+	filerec->WriteTime=filerec->CreatedTime;
+	filerec->WriteDate=filerec->CreatedDate;
+	filerec->FirstClusterLow=0x0000;
+	filerec->FileSize=0x00000000;
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void dir_setFirstCluster(File *file,euint32 cluster_addr)
+ * Description: This function requires modification to release it from
+ * depending on the file object.
+ * Return value:
+*/
+void dir_setFirstCluster(FileSystem *fs,FileLocation *loc,euint32 cluster_addr)
+{
+	euint8 *buf;
+ 	
+ 	buf = part_getSect(fs->part,loc->Sector,IOM_MODE_READWRITE);
+	(((FileRecord*)buf)+loc->Offset)->FirstClusterHigh=cluster_addr>>16;
+	(((FileRecord*)buf)+loc->Offset)->FirstClusterLow=cluster_addr&0xFFFF;	
+	part_relSect(fs->part,buf);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void dir_setFileSize(FileSystem *fs, FileLocation *loc,euint32 numbytes)
+ * Description: This function changes the filesize recorded at loc->Sector
+ * to 'numbytes'.
+ * Return value: void
+*/
+void dir_setFileSize(FileSystem *fs, FileLocation *loc,euint32 numbytes)
+{
+	euint8 *buf;
+	
+	buf = part_getSect(fs->part,loc->Sector,IOM_MODE_READWRITE);
+	(((FileRecord*)buf)+loc->Offset)->FileSize=numbytes;
+	part_relSect(fs->part,buf);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * esint8 dir_updateDirectoryEntry(FileSystem *fs,FileRecord *entry,FileLocation *loc))
+ * This function changes the entire entity stores at loc to the data recorded
+ * in entry. This is for custom updates to the directoryentry.
+ * Return value: 0 on success, -1 on failure
+*/
+esint8 dir_updateDirectoryEntry(FileSystem *fs,FileRecord *entry,FileLocation *loc)
+{
+	euint8 *buf;
+	
+	buf = part_getSect(fs->part,loc->Sector,IOM_MODE_READWRITE);
+	memCpy(entry,buf+(loc->Offset*sizeof(*entry)),sizeof(*entry));
+	part_relSect(fs->part,buf);
+	return(0);
+}
+
+/* ****************************************************************************  
+ * euint32 dir_findFileinBuf(euint8 *buf, eint8 *fatname, FileLocation *loc)
+ * This function searches for a given fatfilename in the buffer provided.
+ * It will iterate through the 16 direntry's in the buffer and searches
+ * for the fatfilename. If found, it will store the offset and attribute
+ * entry of the directoryrecord in the loc structure.
+ * If loc is 0, then it's members are not touched.
+ * Return value: This function returns 0 when it cannot find the file,
+ * if it can find the file it will return the first cluster number.
+*/
+euint32 dir_findFileinBuf(euint8 *buf, eint8 *fatname, FileLocation *loc)
+{
+	FileRecord fileEntry;
+	euint8 c;
+	
+	for(c=0; c<16; c++)
+	{
+		fileEntry = *(((FileRecord*)buf) + c);
+		/* Check if the entry is for short filenames */
+		if( !( (fileEntry.Attribute & 0x0F) == 0x0F ) )
+		{
+			if( strMatch((eint8*)fileEntry.FileName,fatname,11) == 0 )
+			{
+				/* The entry has been found, return the location in the dir */
+				if(loc)loc->Offset = c;
+				if(loc)loc->attrib = fileEntry.Attribute;
+				if((((euint32 )fileEntry.FirstClusterHigh)<<16)+ fileEntry.FirstClusterLow==0){
+					return(1); /* Lie about cluster, 0 means not found! */
+				}else{
+					return
+							(
+							(((euint32 )fileEntry.FirstClusterHigh)<<16)
+							+ fileEntry.FirstClusterLow
+							);
+				}
+			}
+		}
+	}
+	return(0);
+}
+
+/* ****************************************************************************  
+ * euint32 dir_findFreeEntryinBuf(euint8* buf, FileLocation *loc)
+ * This function searches for a free entry in a given sector 'buf'.
+ * It will put the offset into the loc->Offset field, given that loc is not 0.
+ * Return value: 1 when it found a free spot, 0 if it hasn't.
+*/
+euint32 dir_findFreeEntryinBuf(euint8* buf, FileLocation *loc)
+{
+	FileRecord fileEntry;
+	euint8 c;
+	
+	for(c=0;c<16;c++){
+		fileEntry = *(((FileRecord*)buf) + c);
+		if( !( (fileEntry.Attribute & 0x0F) == 0x0F ) ){
+			if(fileEntry.FileName[0] == 0x00 ||
+			   fileEntry.FileName[0] == 0xE5 ){
+				if(loc)loc->Offset=c;
+				return(1);
+			}
+		}
+	}
+	return(0);
+}
+
+/* ****************************************************************************  
+ * euint32  dir_findinBuf(euint8 *buf, eint8 *fatname, FileLocation *loc)
+ * Description: This function searches for a given fatfilename in a buffer.
+ * Return value: Returns 0 on not found, and the firstcluster when the name is found.
+*/
+euint32  dir_findinBuf(euint8 *buf, eint8 *fatname, FileLocation *loc, euint8 mode)
+{
+	switch(mode){
+		case DIRFIND_FILE:
+			return(dir_findFileinBuf(buf,fatname,loc));
+			break;
+		case DIRFIND_FREE:
+			return(dir_findFreeEntryinBuf(buf,loc));
+			break;
+		default:
+			return(0);
+			break;
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 dir_findinCluster(FileSystem *fs,euint32 cluster,eint8 *fatname, FileLocation *loc, euint8 mode)
+ * This function will search for an existing (fatname) or free directory entry
+ * in a full cluster.
+ * Return value: 0 on failure, firstcluster on finding file, and 1 on finding free spot.
+*/
+euint32 dir_findinCluster(FileSystem *fs,euint32 cluster,eint8 *fatname, FileLocation *loc, euint8 mode)
+{
+	euint8 c,*buf=0;
+	euint32 fclus;
+	
+	for(c=0;c<fs->volumeId.SectorsPerCluster;c++){
+		buf = part_getSect(fs->part,fs_clusterToSector(fs,cluster)+c,IOM_MODE_READONLY);
+		fclus=dir_findinBuf(buf,fatname,loc,mode);

+		

+		if(fclus)

+		{
+			if(loc)loc->Sector=fs_clusterToSector(fs,cluster)+c;
+			part_relSect(fs->part,buf);
+			return(fclus);
+		}
+		part_relSect(fs->part,buf);	
+	}
+	part_relSect(fs->part,buf);
+	return(0);
+}
+
+/* ****************************************************************************  
+ * euint32 dir_findinDir(FileSystem *fs, eint8* fatname,euint32 firstcluster, FileLocation *loc, euint8 mode)
+ * This function will search for an existing (fatname) or free directory entry
+ * in a directory, following the clusterchains.
+ * Return value: 0 on failure, firstcluster on finding file, and 1 on finding free spot.
+*/
+euint32 dir_findinDir(FileSystem *fs, eint8* fatname,euint32 firstcluster, FileLocation *loc, euint8 mode)
+{
+	euint32 c=0,cluster;
+	ClusterChain Cache;
+	
+	Cache.DiscCluster = Cache.FirstCluster = firstcluster;
+	Cache.LogicCluster = Cache.LastCluster = Cache.Linear = 0;
+	
+	if(firstcluster <= 1){
+		return(dir_findinRootArea(fs,fatname,loc,mode));	
+	}
+	
+	while(!fat_LogicToDiscCluster(fs,&Cache,c++)){
+		if((cluster=dir_findinCluster(fs,Cache.DiscCluster,fatname,loc,mode))){
+			return(cluster);
+		}
+	}
+	return(0);
+}
+
+/* ****************************************************************************  
+ * euint32 dir_findinDir(FileSystem *fs, eint8* fatname,euint32 firstcluster, FileLocation *loc, euint8 mode)
+ * This function will search for an existing (fatname) or free directory entry
+ * in the rootdirectory-area of a FAT12/FAT16 filesystem.
+ * Return value: 0 on failure, firstcluster on finding file, and 1 on finding free spot.
+*/
+euint32 dir_findinRootArea(FileSystem *fs,eint8* fatname, FileLocation *loc, euint8 mode)
+{
+	euint32 c,fclus;
+	euint8 *buf=0;
+	
+	if((fs->type != FAT12) && (fs->type != FAT16))return(0);
+	
+	for(c=fs->FirstSectorRootDir;c<(fs->FirstSectorRootDir+fs->volumeId.RootEntryCount/32);c++){
+		buf = part_getSect(fs->part,c,IOM_MODE_READONLY);
+		if((fclus=dir_findinBuf(buf,fatname,loc,mode))){
+			if(loc)loc->Sector=c;
+			part_relSect(fs->part,buf);
+			return(fclus);
+		}	
+		part_relSect(fs->part,buf);	
+	}
+	part_relSect(fs->part,buf);
+	return(0);
+}
+
+/* ****************************************************************************  
+ * esint8 dir_getFatFileName(eint8* filename, eint8* fatfilename)
+ * This function will take a full directory path, and strip off all leading
+ * dirs and characters, leaving you with the MS-DOS notation of the actual filename.
+ * Return value: 1 on success, 0 on not being able to produca a filename
+*/
+esint8 dir_getFatFileName(eint8* filename, eint8* fatfilename)
+{
+	eint8 ffnamec[11],*next,nn=0;
+	
+	memClr(ffnamec,11); memClr(fatfilename,11);
+	next = filename;
+	
+	if(*filename=='/')next++;
+	
+	while((next=file_normalToFatName(next,ffnamec))){
+		memCpy(ffnamec,fatfilename,11);	
+		nn++;
+	}
+	if(nn)return(1);
+	return(0);
+}
+
+/* ****************************************************************************  
+ * esint8 dir_addCluster(FileSystem *fs,euint32 firstCluster)
+ * This function extends a directory by 1 cluster + optional the number of
+ * clusters you want pre-allocated. It will also delete the contents of that
+ * cluster. (or clusters)
+ * Return value: 0 on success, -1 on fail
+*/
+esint8 dir_addCluster(FileSystem *fs,euint32 firstCluster)
+{
+	euint32 lastc,logicalc;
+	ClusterChain cache;
+		
+	fs_initClusterChain(fs,&cache,firstCluster);
+	if(fat_allocClusterChain(fs,&cache,1)){
+		return(-1);
+	}
+	lastc = fs_getLastCluster(fs,&cache);
+	if(CLUSTER_PREALLOC_DIRECTORY){
+		if(fat_allocClusterChain(fs,&cache,CLUSTER_PREALLOC_DIRECTORY)){
+			return(-1);
+		}
+		logicalc = fat_DiscToLogicCluster(fs,firstCluster,lastc);
+		while(!fat_LogicToDiscCluster(fs,&cache,++logicalc)){
+			fs_clearCluster(fs,cache.DiscCluster);
+		}
+	}else{
+			fs_clearCluster(fs,lastc);
+	}
+	return(0);
+}
+
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/fat.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/fat.c
new file mode 100644
index 0000000000..b9f856cf10
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/fat.c
@@ -0,0 +1,577 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : fat.c                                                            *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains all the functions dealing with the FAT     *
+*               in a Microsoft FAT filesystem. It belongs under fs.c          *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "fs.h"
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * unsigned long fat_getSectorAddressFatEntry(FileSystem *fs,unsigned long cluster_addr)
+ * Description: Returns the sectornumber that holds the fat entry for cluster cluster_addr.
+ * This works for all FAT types.
+ * Return value: Sectornumber, or 0. Warning, no boundary check.
+*/
+euint32 fat_getSectorAddressFatEntry(FileSystem *fs,euint32 cluster_addr)
+{ 
+	euint32 base = fs->volumeId.ReservedSectorCount,res;
+	
+	switch(fs->type){
+		case FAT12:
+			res=(cluster_addr*3/1024);
+			if(res>=fs->FatSectorCount){
+				return(0);
+			}else{
+				return(base+res);
+			}
+			break;
+		case FAT16:
+			res=cluster_addr/256;
+			if(res>=fs->FatSectorCount){
+				return(0);
+			}else{
+				return(base+res);
+			}
+			break;
+		case FAT32:
+			res=cluster_addr/128;
+			if(res>=fs->FatSectorCount){
+				return(0);
+			}else{
+				return(base+res);
+			}
+			break; 
+	}
+	return(0);
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * unsigned long fat_getNextClusterAddress(FileSystem *fs,unsigned long cluster_addr
+ * Description: This function loads the sector of the fat which contains the entry
+ * for cluster_addr. It then fetches and (if required) calculates it's value.
+ * This value is the EoC marker -or- the number of the next cluster in the chain.
+ * Return value: Clusternumber or EoC
+*/
+euint32 fat_getNextClusterAddress(FileSystem *fs,euint32 cluster_addr,euint16 *linear)
+{
+	euint8 *buf; 
+	euint8 hb,lb;
+	euint16 offset;
+	euint32 sector;
+	euint32 nextcluster=0;
+	
+	sector=fat_getSectorAddressFatEntry(fs,cluster_addr);
+	if( (fs->FatSectorCount <= (sector-fs->volumeId.ReservedSectorCount)) || sector==0 )
+	{
+		return(0);
+	}
+	
+	buf=part_getSect(fs->part,sector,IOM_MODE_READONLY);
+		
+	switch(fs->type)
+	{
+		case FAT12:
+			offset = ((cluster_addr%1024)*3/2)%512;
+			hb = buf[offset];
+			if(offset == 511){
+				part_relSect(fs->part,buf);
+				buf=part_getSect(fs->part,sector+1,IOM_MODE_READONLY);
+				lb = buf[0];
+			}else{
+				lb = buf[offset + 1];
+			}
+			if(cluster_addr%2==0){
+				nextcluster = ( ((lb&0x0F)<<8) + (hb) );
+			}else{
+				nextcluster = ( (lb<<4) + (hb>>4) );
+			}
+			break;
+		case FAT16:
+			offset=cluster_addr%256;
+			nextcluster = *((euint16 *)buf + offset);
+			break;
+		case FAT32:
+			offset=cluster_addr%128;
+			nextcluster = *((euint32 *)buf + offset);
+			break;
+	}
+	
+	part_relSect(fs->part,buf);
+	
+	return(nextcluster);
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * void fat_setNextClusterAddress(FileSystem *fs,unsigned long cluster_addr,unsigned long next_cluster_addr)
+ * Description: This function makes an entry in the fattable for cluster_addr. The value it puts there
+ * is next_cluster_addr. 
+*/
+void fat_setNextClusterAddress(FileSystem *fs,euint32 cluster_addr,euint32 next_cluster_addr)
+{
+	euint8 *buf,*buf2; 
+	euint16 offset;
+	euint32 sector;
+	
+	sector=fat_getSectorAddressFatEntry(fs,cluster_addr);
+	if(fs->FatSectorCount<sector){
+		DBG((TXT("HARDERROR:::fat_getNextClusterAddress READ PAST FAT BOUNDARY\n")));
+		return;
+	}
+	
+	buf=part_getSect(fs->part,sector,IOM_MODE_READWRITE);
+		
+	switch(fs->type){
+		case FAT12:
+			offset = ((cluster_addr%1024)*3/2)%512;
+			if(offset == 511){
+				if(cluster_addr%2==0){
+					buf[offset]=next_cluster_addr&0xFF;
+				}else{
+					buf[offset]=(buf[offset]&0xF)+((next_cluster_addr<<4)&0xF0);
+				}
+				buf2=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,cluster_addr)+1,IOM_MODE_READWRITE);
+				if(cluster_addr%2==0){
+					buf2[0]=(buf2[0]&0xF0)+((next_cluster_addr>>8)&0xF);
+				}else{
+					buf2[0]=(next_cluster_addr>>4)&0xFF;
+				}
+				part_relSect(fs->part,buf2);
+			}else{
+				if(cluster_addr%2==0){
+					buf[offset]=next_cluster_addr&0xFF;
+					buf[offset+1]=(buf[offset+1]&0xF0)+((next_cluster_addr>>8)&0xF);
+				}else{
+					buf[offset]=(buf[offset]&0xF)+((next_cluster_addr<<4)&0xF0);
+					buf[offset+1]=(next_cluster_addr>>4)&0xFF;
+				}
+			}
+			part_relSect(fs->part,buf);
+			break;
+		case FAT16:
+			offset=cluster_addr%256;
+			*((euint16*)buf+offset)=next_cluster_addr;
+			part_relSect(fs->part,buf);
+			break;
+		case FAT32:
+			offset=cluster_addr%128;
+			*((euint32*)buf+offset)=next_cluster_addr;
+			part_relSect(fs->part,buf);
+			break;
+	}
+	
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * short fat_isEocMarker(FileSystem *fs,unsigned long fat_entry)
+ * Description: Checks if a certain value is the EoC marker for the filesystem
+ * noted in fs->type.
+ * Return value: Returns 0 when it is the EoC marker, and 1 otherwise.
+*/
+eint16 fat_isEocMarker(FileSystem *fs,euint32 fat_entry)
+{
+	switch(fs->type){
+		case FAT12:
+			if(fat_entry<0xFF8){
+				return(0);
+			}
+			break;
+		case FAT16:
+			if(fat_entry<0xFFF8){
+				return(0);
+			}
+			break;
+		case FAT32:
+			if((fat_entry&0x0FFFFFFF)<0xFFFFFF8){
+				return(0);
+			}
+			break;
+	}
+	return(1);
+}
+/*****************************************************************************/ 
+
+
+/* ****************************************************************************  
+ * unsigned long fat_giveEocMarker(FileSystem *fs)
+ * Description: Returns an EoC markernumber valid for the filesystem noted in
+ * fs->type.
+ * Note, for FAT32, the upper 4 bits are set to zero, although they should be un
+ * touched according to MicroSoft specifications. I didn't care.
+ * Return value: The EoC marker cast to an ulong.
+*/
+euint32 fat_giveEocMarker(FileSystem *fs)
+{
+	switch(fs->type)
+	{
+		case FAT12:
+			return(0xFFF);
+			break;
+		case FAT16:
+			return(0xFFFF);
+			break;
+		case FAT32:
+			return(0x0FFFFFFF);
+			break;
+	}
+	return(0);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * euint32 fat_getNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr, euint8* buf)
+ * Description: This function retrieves the contents of a FAT field. It does not fetch
+ * it's own buffer, it is given as a parameter. (ioman makes this function rather obsolete)
+ * Only in the case of a FAT12 crosssector data entry a sector is retrieved here.
+ * Return value: The value of the clusterfield is returned.
+*/
+euint32 fat_getNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr, euint8* buf)
+{
+	euint8  *buf2; /* For FAT12 fallover only */
+	euint8 hb,lb;
+	euint16 offset;
+	euint32 nextcluster=0;
+	
+	switch(fs->type)
+	{
+		case FAT12:
+			offset = ((cluster_addr%1024)*3/2)%512;
+			hb = buf[offset];
+			if(offset == 511){
+				buf2=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,cluster_addr)+1,IOM_MODE_READONLY);
+				lb = buf2[0];
+				part_relSect(fs->part,buf2);
+			}else{
+				lb = buf[offset + 1];
+			}
+			if(cluster_addr%2==0){
+				nextcluster = ( ((lb&0x0F)<<8) + (hb) );
+			}else{
+				nextcluster = ( (lb<<4) + (hb>>4) );
+			}
+			break;
+		case FAT16:
+			offset=cluster_addr%256;
+			nextcluster = *((euint16*)buf + offset);
+			break;
+		case FAT32:
+			offset=cluster_addr%128;
+			nextcluster = *((euint32*)buf + offset);
+			break;
+	}
+	return(nextcluster);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * void fat_setNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr,euint32 next_cluster_addr,euint8* buf)
+ * Description: This function fills in a fat entry. The entry is cluster_addr and the
+ * data entered is next_cluster_addr. This function is also given a *buf, so it does
+ * not write the data itself, except in the case of FAT 12 cross sector data, where
+ * the second sector is handled by this function.
+ * Return value:
+*/
+void fat_setNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr,euint32 next_cluster_addr,euint8* buf)
+{
+	euint16 offset;
+	euint8 *buf2;
+		
+	switch(fs->type)
+	{
+		case FAT12:
+			offset = ((cluster_addr%1024)*3/2)%512;
+			if(offset == 511){
+				if(cluster_addr%2==0){
+					buf[offset]=next_cluster_addr&0xFF;
+				}else{
+					buf[offset]=(buf[offset]&0xF)+((next_cluster_addr<<4)&0xF0);
+				}
+				buf2=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,cluster_addr)+1,IOM_MODE_READWRITE);
+				if(cluster_addr%2==0){
+					buf2[0]=(buf2[0]&0xF0)+((next_cluster_addr>>8)&0xF);
+				}else{
+					buf2[0]=(next_cluster_addr>>4)&0xFF;
+				}
+				part_relSect(fs->part,buf2);
+			}else{
+				if(cluster_addr%2==0){
+					buf[offset]=next_cluster_addr&0xFF;
+					buf[offset+1]=(buf[offset+1]&0xF0)+((next_cluster_addr>>8)&0xF);
+				}else{
+					buf[offset]=(buf[offset]&0xF)+((next_cluster_addr<<4)&0xF0);
+					buf[offset+1]=(next_cluster_addr>>4)&0xFF;
+				}
+			}
+			break;
+		case FAT16:
+			offset=cluster_addr%256;
+			*((euint16*)buf+offset)=next_cluster_addr;
+			break;
+		case FAT32:
+			offset=cluster_addr%128;
+			*((euint32*)buf+offset)=next_cluster_addr;
+			break;
+	}
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * esint16 fat_getNextClusterChain(FileSystem *fs, ClusterChain *Cache)
+ * Description: This function is to advance the clusterchain of a Cache.
+ * First, the function verifies if the Cache is valid. It could correct it if it 
+ * is not, but this is not done at the time. If the cachen is valid, the next step is
+ * to see what the next cluster is, if this is the End of Clustermark, the cache is
+ * updated to know the lastcluster but will remain untouched otherwise. -1 is returned.
+ * If there are more clusters the function scans the rest of the chain until the next
+ * cluster is no longer lineair, or until it has run out of fat data (only 1 sector) is
+ * examined, namely the one fetched to check for EoC.
+ * With lineair is meant that logical cluster n+1 should be 1 more than logical cluster n
+ * at the disc level.
+ * Return value: 0 on success, or -1 when EoC.
+*/
+esint16 fat_getNextClusterChain(FileSystem *fs, ClusterChain *Cache)
+{
+	euint32 sect,lr,nlr,dc;
+	esint16 lin=0;
+	euint8 *buf;
+
+	if(Cache->DiscCluster==0)
+	{
+		return(-1);
+	}
+
+	sect=fat_getSectorAddressFatEntry(fs,Cache->DiscCluster);
+	buf=part_getSect(fs->part,sect,IOM_MODE_READONLY);
+	dc=fat_getNextClusterAddressWBuf(fs,Cache->DiscCluster,buf);
+	if(fat_isEocMarker(fs,dc))
+	{
+		Cache->LastCluster=Cache->DiscCluster;
+		part_relSect(fs->part,buf);
+		return(-1);
+	}
+	
+	Cache->DiscCluster=dc;
+	Cache->LogicCluster++;
+		
+	lr=Cache->DiscCluster-1;
+	nlr=lr+1;
+	
+	while(nlr-1==lr && fat_getSectorAddressFatEntry(fs,nlr)==sect)
+	{
+		lr=nlr;
+		nlr=fat_getNextClusterAddressWBuf(fs,lr,buf);
+		lin++;	
+	}
+	
+	Cache->Linear=lin-1<0?0:lin-1;
+	
+	part_relSect(fs->part,buf);
+	return(0);
+}
+/*****************************************************************************/
+
+
+/* ****************************************************************************  
+ * esint16 fat_LogicToDiscCluster(FileSystem *fs, ClusterChain *Cache,euint32 logiccluster)
+ * Description: This function is used to follow clusterchains. When called it will convert
+ * a logical cluster, to a disc cluster, using a Cache object. All it does is call
+ * getNextClusterChain in the proper manner, and rewind clusterchains if required.
+ * It is NOT recommended to go backwards in clusterchains, since this will require
+ * scanning the entire chain every time.
+ * Return value: 0 on success and -1 on failure (meaning out of bounds).
+*/
+esint16 fat_LogicToDiscCluster(FileSystem *fs, ClusterChain *Cache,euint32 logiccluster)
+{
+	if(logiccluster<Cache->LogicCluster || Cache->DiscCluster==0){
+		Cache->LogicCluster=0;
+		Cache->DiscCluster=Cache->FirstCluster;
+		Cache->Linear=0;
+	}
+	
+	if(Cache->LogicCluster==logiccluster){
+		return(0);
+	}
+	
+	while(Cache->LogicCluster!=logiccluster)
+	{
+		if(Cache->Linear!=0)
+		{
+			Cache->Linear--;
+			Cache->LogicCluster++;
+			Cache->DiscCluster++;
+		}
+		else
+		{
+			if((fat_getNextClusterChain(fs,Cache))!=0){
+				return(-1);
+			}
+		}
+	}
+	return(0);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * eint16 fat_allocClusterChain(FileSystem *fs,ClusterChain *Cache,euint32 num_clusters)
+ * Description: This function extends a clusterchain by num_clusters. It returns the
+ * number of clusters it *failed* to allocate. 
+ * Return value: 0 on success, all other values are the number of clusters it could
+ * not allocate.
+*/
+eint16 fat_allocClusterChain(FileSystem *fs,ClusterChain *Cache,euint32 num_clusters)
+{
+	euint32 cc,ncl=num_clusters,lc;
+	euint8 *bufa=0,*bufb=0;
+	euint8  overflow=0;
+
+	if(Cache->FirstCluster<=1)return(num_clusters);
+	
+	lc=fs_getLastCluster(fs,Cache);
+	cc=lc;
+	
+	while(ncl > 0){
+		cc++;
+		if(cc>=fs->DataClusterCount+1){
+			if(overflow){
+				bufa=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,lc),IOM_MODE_READWRITE);
+				fat_setNextClusterAddressWBuf(fs,lc,fat_giveEocMarker(fs),bufa);
+				Cache->LastCluster=lc;
+				part_relSect(fs->part,bufa);
+				return(num_clusters-ncl);
+			}
+			cc=2;
+			overflow++;
+		}
+		bufa=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,cc),IOM_MODE_READONLY);
+		if(fat_getNextClusterAddressWBuf(fs,cc,bufa)==0){
+			bufb=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,lc),IOM_MODE_READWRITE);
+			fat_setNextClusterAddressWBuf(fs,lc,cc,bufb);
+			part_relSect(fs->part,bufb);
+			ncl--;
+			lc=cc;
+		}
+		part_relSect(fs->part,bufa);
+		if(ncl==0){
+			bufa=part_getSect(fs->part,fat_getSectorAddressFatEntry(fs,lc),IOM_MODE_READWRITE);
+			fat_setNextClusterAddressWBuf(fs,lc,fat_giveEocMarker(fs),bufa);
+			Cache->LastCluster=lc;
+			part_relSect(fs->part,bufa);
+		}
+	}
+	return(0);
+}
+
+/* ****************************************************************************  
+ * eint16 fat_unlinkClusterChain(FileSystem *fs,ClusterChain *Cache)
+ * Description: This function removes a clusterchain. Starting at FirstCluster
+ * it follows the chain until the end, resetting all values to 0.
+ * Return value: 0 on success.
+*/
+eint16 fat_unlinkClusterChain(FileSystem *fs,ClusterChain *Cache)
+{
+	euint32 c,tbd=0;
+	
+	Cache->LogicCluster=0;
+	Cache->DiscCluster=Cache->FirstCluster;
+	
+	c=0;
+	
+	while(!fat_LogicToDiscCluster(fs,Cache,c++)){
+		if(tbd!=0){
+			fat_setNextClusterAddress(fs,tbd,0);
+		}
+		tbd=Cache->DiscCluster;
+	}
+	fat_setNextClusterAddress(fs,Cache->DiscCluster,0);
+ 	return(0);
+}
+
+euint32 fat_countClustersInChain(FileSystem *fs,euint32 firstcluster)
+{
+	ClusterChain cache;
+	euint32 c=0;
+	
+	if(firstcluster<=1)return(0);
+	
+	cache.DiscCluster = cache.LogicCluster = cache.LastCluster = cache.Linear = 0;
+	cache.FirstCluster = firstcluster;
+	
+	while(!(fat_LogicToDiscCluster(fs,&cache,c++)));
+	
+	return(c-1);
+}
+
+euint32 fat_DiscToLogicCluster(FileSystem *fs,euint32 firstcluster,euint32 disccluster)
+{
+	ClusterChain cache;
+	euint32 c=0,r=0;
+	
+	cache.DiscCluster = cache.LogicCluster = cache.LastCluster = cache.Linear = 0;
+	cache.FirstCluster = firstcluster;
+	
+	while(!(fat_LogicToDiscCluster(fs,&cache,c++)) && !r){
+		if(cache.DiscCluster == disccluster){
+			r = cache.LogicCluster;
+		}
+	}
+	return(r);
+}
+
+void fat_ShortnameToString(const euint8* src, eint8* nm)
+{
+	register eint32 i;
+
+	i = 8;
+	while (i-- && *src != ' ')
+	{
+		*nm++ = *src++;
+	}
+
+	src += i + 1;
+	if (*src > ' ')
+	{
+		*nm++ = '.';
+		i = 3;
+		while (i-- && *src != ' ')
+		{
+			*nm++ = *src++;
+		}
+	}
+
+	*nm = '\0';
+}
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/file.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/file.c
new file mode 100644
index 0000000000..436989edc0
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/file.c
@@ -0,0 +1,551 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : file.c                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions dealing with files such as:      *
+*               fopen, fread and fwrite.                                      *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include <dfs_fs.h>
+
+#include "file.h"
+#include "ui.h"
+/*****************************************************************************/
+/* ****************************************************************************  
+ * euint32 file_fread(File *file,euint32 offset, euint32 size,euint8 *buf)
+ * Description: This function reads 'size' bytes from 'file' starting at
+ * 'offset' and puts the result in '*buf'.
+ * Return value: amount of bytes actually read (can differ from the given
+ * size when the file was smaller
+*/
+euint32 file_fread(File *file,euint32 offset, euint32 size,euint8 *buf)
+{
+	euint32 bytes_read=0,size_left=size,coffset=offset;
+	euint32 cclus,csec,cbyte;
+	euint32 rclus,rsec;
+	euint32 btr;
+	euint8 *tbuf;
+
+	if(!file_getAttr(file,FILE_STATUS_OPEN))return(0);
+	
+	if(offset>=file->FileSize)
+		size_left=0; /* Offset check */
+	
+	if( (offset+size > file->FileSize) && size_left!=0)
+		size_left=file->FileSize-offset;
+	
+	while(size_left>0)

+	{
+		cclus = coffset/(512*file->fs->volumeId.SectorsPerCluster);
+		csec = (coffset/(512))%file->fs->volumeId.SectorsPerCluster;
+		cbyte = coffset%512;
+		

+		if ((size_left > 512 * file->fs->volumeId.SectorsPerCluster) &&

+			(csec == 0) && (cbyte == 0))

+		{

+			/* read whole cluster */

+			btr = 512 * file->fs->volumeId.SectorsPerCluster;

+		}

+		else if(cbyte!=0 || size_left<512)

+		{

+			btr = 512-(coffset%512) >= size_left? size_left:512-(coffset%512);
+		}

+		else

+		{

+			/* whole sector */
+			btr = 512;
+		}
+		
+		if((fat_LogicToDiscCluster(file->fs,&(file->Cache),cclus))!=0){
+			return(0);
+		}

+		
+		rclus = file->Cache.DiscCluster;
+		rsec  = fs_clusterToSector(file->fs,rclus);
+		
+		if(btr > 512)

+		{
+			part_directSectorRead(file->fs->part, rsec + csec, buf + bytes_read, btr / 512);
+		}

+		else

+		{
+			tbuf = part_getSect(file->fs->part,rsec+csec,IOM_MODE_READONLY);
+			memCpy(tbuf+(coffset%512),buf+bytes_read,btr);
+			part_relSect(file->fs->part,tbuf);
+		}
+		
+		coffset+=btr;
+		bytes_read+=btr;
+		size_left-=btr;
+	}
+
+	return(bytes_read);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 file_read (File *file,euint32 size,euint8 *buf)
+ * Description: This function reads from a file, taking the FilePtr into account
+ * and advancing it according to the freadcall.
+ * Return value: Value obtained from fread
+*/
+euint32 file_read(File *file,euint32 size,euint8 *buf)
+{
+	euint32 r;
+	
+	r=file_fread(file,file->FilePtr,size,buf);
+	file->FilePtr+=r;
+	return(r);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 file_write(File *file, euint32 size,euint8 *buf)
+ * Description: This function writes to a file, taking FilePtr into account
+ * and advancing it according to the fwritecall.
+ * Return value: Value obtained from fread
+*/
+euint32 file_write(File *file, euint32 size,euint8 *buf)
+{
+	euint32 r;
+	
+	r=file_fwrite(file,file->FilePtr,size,buf);
+	file->FilePtr+=r;
+	return(r);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * esint32 file_setpos(File *file,euint32 pos)
+ * Description: This function does a sanity check on the requested position
+ * and changes the fileptr accordingly.
+ * Return value: 0 on success and -1 on failure.
+*/
+esint32 file_setpos(File *file,euint32 pos)
+{
+	if(pos<=file->FileSize){
+		file->FilePtr=pos;
+		return(pos);
+	}
+	return(-1);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 file_fwrite(File* file,euint32 offset,euint32 size,euint8* buf)
+ * Description: This function writes to a file, at offset 'offset' and size 'size'.
+ * It also updates the FileSize in the object, and discstructure.
+ * Return value: Bytes actually written.
+*/
+euint32 file_fwrite(File* file,euint32 offset,euint32 size,euint8* buf)
+{
+	euint32 need_cluster;
+	euint32 cclus,csec,cbyte;
+	euint32 size_left=size,bytes_written=0;
+	euint32 rclus,rsec;
+	euint32 coffset=offset;
+	euint16 btr;
+	euint8 *tbuf;
+
+	if(!file_getAttr(file,FILE_STATUS_OPEN) || !file_getAttr(file,FILE_STATUS_WRITE))return(0);
+	
+	if(offset>file->FileSize){
+		offset=file->FileSize;
+	}
+	
+	need_cluster = file_requiredCluster(file,offset,size);
+	
+	if(need_cluster){
+		if(fat_allocClusterChain(file->fs,&(file->Cache),need_cluster+CLUSTER_PREALLOC_FILE)!=0){
+			return(0);
+		}
+	}
+	
+	while(size_left>0){
+	
+		cclus = coffset/(512*file->fs->volumeId.SectorsPerCluster);
+		csec = (coffset/(512))%file->fs->volumeId.SectorsPerCluster;
+		cbyte = coffset%512;
+		
+		if ((size_left > 512 * file->fs->volumeId.SectorsPerCluster) &&

+			(csec == 0) && (cbyte == 0))

+		{

+			/* write whole cluster */

+			btr = 512 * file->fs->volumeId.SectorsPerCluster;

+		}

+		else if(cbyte!=0 || size_left<512)

+		{
+			btr = 512- (coffset%512) >= size_left? size_left:512-(coffset%512);
+		}

+		else

+		{

+			/* whole sector */
+			btr = 512;
+		}
+
+		if((fat_LogicToDiscCluster(file->fs,&(file->Cache),cclus))!=0){
+			file->FileSize+=bytes_written;
+			dir_setFileSize(file->fs,&(file->Location),file->FileSize);
+			return(bytes_written);
+		}
+		rclus=file->Cache.DiscCluster;
+		rsec=fs_clusterToSector(file->fs,rclus);
+		
+		if(btr > 512)

+		{
+			part_directSectorWrite(file->fs->part, rsec + csec, buf + bytes_written, btr / 512);
+		}

+		else

+		{
+			tbuf = part_getSect(file->fs->part,rsec+csec,IOM_MODE_READWRITE);
+			memCpy(buf+bytes_written, tbuf+(coffset%512), btr);
+			part_relSect(file->fs->part,tbuf);
+		}
+		
+		coffset+=btr;
+		bytes_written+=btr;
+		size_left-=btr;
+	}
+	
+	if(bytes_written>file->FileSize-offset){
+		file->FileSize+=bytes_written-(file->FileSize-offset);
+    }
+	
+	return(bytes_written);	
+}
+
+/* ****************************************************************************  
+ * esint8 file_fclose(File *file)
+ * Description: This function closes a file, by clearing the object.
+ * Return value: 0 on success.
+*/
+esint8 file_fclose(File *file)
+{
+	if(fs_hasTimeSupport()){
+		file->DirEntry.AccessDate = time_getDate();
+		if(file_getAttr(file,FILE_STATUS_WRITE)){
+			file->DirEntry.FileSize = file->FileSize;
+			file->DirEntry.WriteDate = file->DirEntry.AccessDate;
+			file->DirEntry.WriteTime = time_getTime();
+		}
+		dir_updateDirectoryEntry(file->fs,&(file->DirEntry),&(file->Location));
+	}else{
+		if(file_getAttr(file,FILE_STATUS_WRITE)){
+			dir_setFileSize(file->fs,&(file->Location),file->FileSize);
+		}
+	}
+	
+	memClr(file,sizeof(*file));
+	file_setAttr(file,FILE_STATUS_OPEN,0);
+	file_setAttr(file,FILE_STATUS_WRITE,0);
+	return(0);
+}
+
+
+/* ****************************************************************************  
+ * void file_initFile(File *file, FileSystem *fs, FileLocation *loc)
+ * Description: This function initialises a new file object, by filling in
+ * the fs pointer, filesize (note, that DirEntry must already be filled in)
+ * and known cache parameters.
+ * Return value: void
+*/
+void file_initFile(File *file, FileSystem *fs, FileLocation *loc)
+{
+	file->fs=fs;
+	file->FileSize=file->DirEntry.FileSize;
+	file->FilePtr=0;
+	file->Location.Sector=loc->Sector;
+	file->Location.Offset=loc->Offset;
+	file->Cache.Linear=0;
+	file->Cache.FirstCluster=(((euint32)file->DirEntry.FirstClusterHigh)<<16)+ 
+	                                    file->DirEntry.FirstClusterLow;
+	file->Cache.LastCluster=0; 
+	file->Cache.LogicCluster=0;
+	file->Cache.DiscCluster=file->Cache.FirstCluster;
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint8* file_normalToFatName(eint8* filename,eint8* fatfilename)
+ * Description: This function converts a human readable filename (limited to 
+ * 8.3 eint8 character) to a valid FAT (not VFAT) filename. Invalid characters are 
+ * changed to capital X and only the first 11 characters are used.
+ * Furthermore all letters are capitalised.
+ * Return value: pointer after the filename
+*/
+eint8* file_normalToFatName(eint8* filename,eint8* fatfilename)
+{
+	euint8 c,dot=0,vc=0;
+	
+	for(c=0;c<11;c++)fatfilename[c]=' ';
+	
+	c=0;
+	
+	if(*filename == '.'){
+		fatfilename[0]='.';
+		vc++; 
+		if(*(filename+1) == '.'){
+			fatfilename[1]='.';
+			filename+=2;
+		}else{
+			filename++;
+		}
+	}else{
+		while(*filename != '\0' && *filename != ' ' && *filename != '/'){
+			if(*filename=='.' && !dot){
+				dot=1;
+				c=8;
+			}else{
+				if(dot){
+					if(c<=10){
+						fatfilename[c]=file_validateChar(*filename);
+						c++; 
+					}
+				}else{
+					if(c<=7){
+						fatfilename[c]=file_validateChar(*filename);
+						c++; vc++;
+					}
+				}
+			}
+			filename++;
+		}
+	}
+	
+	if(vc>0){
+		if(*filename=='\0'){
+			return(filename);
+		}else{
+			return(filename+1);
+		}
+	}else{
+		return(0);
+	}
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ *
+ * Description: This function takes the character c, and if it is not a       *
+ * valid FAT Filename character returns X. If it is a lowercase letter the    *
+ * uppercase equivalent is returned. The remaining characters are returned    *
+ * as they are.      
+ * Return value: The validated char
+*/
+euint8 file_validateChar(euint8 c)
+{
+    if( (c<0x20) || (c>0x20&&c<0x30&&c!='-') || (c>0x39&&c<0x41) || (c>0x5A&&c<0x61&&c!='_') ||	(c>0x7A&&c!='~') )
+		return(0x58);
+    if( c>=0x61 && c<=0x7A )
+		return(c-32);
+
+	return(c);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void ioman_setAttr(IOManager *ioman,euint16 bufplace,euint8 attribute,euint8 val)
+ * Description: This sets the attribute of 'bufplace' to the given value (binary).
+ *
+ * Return value: void
+*/
+void file_setAttr(File* file,euint8 attribute,euint8 val)
+{
+	if(val){
+		file->FileStatus|=1<<attribute;
+	}else{
+		file->FileStatus&=~(1<<attribute);
+	}
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint8 ioman_getAttr(IOManager *ioman,euint16 bufplace,euint8 attribute)
+ * Description: This function retrieves an attribute from the bufstat array.
+ * It returns nonzero when it attribute is true and 0 when it is false.
+ * Please note, I said "nonzero", not 1.
+ * Return value: Attribute.
+*/
+euint8 file_getAttr(File* file,euint8 attribute)
+{
+	return(file->FileStatus&(1<<attribute));
+}
+/*****************************************************************************/
+
+euint32 file_requiredCluster(File *file,euint32 offset, euint32 size)
+{
+	euint32 clusters_required,clustersize;
+	euint32 hc;
+
+	if((offset+size)>file->FileSize){
+		hc = fat_countClustersInChain(file->fs,file->Cache.FirstCluster);
+		clustersize = file->fs->volumeId.BytesPerSector * file->fs->volumeId.SectorsPerCluster;
+		if((size-file->FileSize+offset)>
+		   ((hc-((file->FileSize+clustersize-1)/clustersize))*clustersize)){
+			clusters_required = (((offset+size)-(hc*clustersize))+clustersize-1)/clustersize;
+		}else{
+			clusters_required = 0;
+		}
+	}else{
+		clusters_required = 0;
+	}
+	return(clusters_required);
+}
+
+esint8 file_fopen(File* file,FileSystem *fs,eint8* filename,eint32 mode)
+{
+	FileLocation loc;
+	FileRecord wtmp;
+	eint8 fatfilename[11];
+	euint32 sec;
+
+	dir_getFatFileName(filename,fatfilename);
+
+	/* create */
+	if(mode & DFS_O_CREAT)
+	{
+		/* file does not exist */
+		if(fs_findFile(fs,filename,&loc,0) == 0)
+		{
+			if(fs_findFreeFile(fs,filename,&loc,0))
+			{
+				dir_createDefaultEntry(fs,&wtmp,fatfilename);
+				dir_createDirectoryEntry(fs,&wtmp,&loc);
+				memCpy(&wtmp,&(file->DirEntry),sizeof(wtmp));
+				file_initFile(file,fs,&loc);
+				sec=fs_getNextFreeCluster(file->fs,fs_giveFreeClusterHint(file->fs));
+				dir_setFirstCluster(file->fs,&(file->Location),sec);
+				fs_setFirstClusterInDirEntry(&(file->DirEntry),sec);
+				fs_initClusterChain(fs,&(file->Cache),sec);
+				fat_setNextClusterAddress(fs,sec,fat_giveEocMarker(fs));
+				
+				if (mode & DFS_O_APPEND) 
+					file_setpos(file,file->FileSize);
+			}
+			else 
+			{
+				dfs_log(DFS_DEBUG_INFO, ("no space left on device"));
+				
+				return -DFS_STATUS_ENOSPC;
+			}	
+		}
+		else if ( mode & DFS_O_EXCL) 
+		{
+			dfs_log(DFS_DEBUG_INFO, ("file has existed"));
+			
+			return -DFS_STATUS_EEXIST;
+		}	
+		/*file exist*/
+		else
+		{
+			dir_getFileStructure(fs,&(file->DirEntry), &loc);
+			file_initFile(file,fs,&loc);
+		}
+		
+		file_setAttr(file,FILE_STATUS_OPEN,1);
+		file_setAttr(file,FILE_STATUS_WRITE,1);
+	}
+	/* write */	
+	else if(mode & DFS_O_WRONLY || mode & DFS_O_RDWR)
+	{
+		/* file does not exist */
+		if(fs_findFile(fs,filename,&loc,0) == 0)
+		{
+			if(fs_findFreeFile(fs,filename,&loc,0))
+			{
+				dir_createDefaultEntry(fs,&wtmp,fatfilename);
+				dir_createDirectoryEntry(fs,&wtmp,&loc);
+				memCpy(&wtmp,&(file->DirEntry),sizeof(wtmp));
+				file_initFile(file,fs,&loc);
+				sec=fs_getNextFreeCluster(file->fs,fs_giveFreeClusterHint(file->fs));
+				dir_setFirstCluster(file->fs,&(file->Location),sec);
+				fs_setFirstClusterInDirEntry(&(file->DirEntry),sec);
+				fs_initClusterChain(fs,&(file->Cache),sec);
+				fat_setNextClusterAddress(fs,sec,fat_giveEocMarker(fs));
+
+				if (mode & DFS_O_APPEND) 
+					file_setpos(file,file->FileSize);
+			}
+			else 
+			{
+				dfs_log(DFS_DEBUG_INFO, ("no space left on device"));
+				
+				return -DFS_STATUS_ENOSPC;
+			}	
+		}
+		else
+		{
+			if (mode & DFS_O_APPEND)
+			{
+				dir_getFileStructure(fs,&(file->DirEntry), &loc);
+				file_initFile(file,fs,&loc);
+				if(file->Cache.FirstCluster==0)
+				{
+					sec=fs_getNextFreeCluster(file->fs,fs_giveFreeClusterHint(file->fs));
+					dir_setFirstCluster(file->fs,&(file->Location),sec);
+					fs_setFirstClusterInDirEntry(&(file->DirEntry),sec);
+					fat_setNextClusterAddress(fs,sec,fat_giveEocMarker(fs));
+					file_initFile(file,fs,&loc);
+					file_setpos(file,file->FileSize);
+				}
+			}
+			else
+			{
+				dir_getFileStructure(fs,&(file->DirEntry), &loc);
+				file_initFile(file,fs,&loc);
+			}
+		}		
+
+		file_setAttr(file,FILE_STATUS_OPEN,1);
+		file_setAttr(file,FILE_STATUS_WRITE,1);
+	}
+	/* read */	
+	else
+	{
+		/* file does not exist */
+		if(fs_findFile(fs,filename,&loc,0) == 0)
+		{
+			dfs_log(DFS_DEBUG_INFO, ("file doesn't exist"));
+			
+			return -DFS_STATUS_ENOENT;
+		}
+		else
+		{
+			dir_getFileStructure(fs,&(file->DirEntry), &loc);
+			file_initFile(file,fs,&loc);
+			
+			file_setAttr(file,FILE_STATUS_OPEN,1);
+			file_setAttr(file,FILE_STATUS_WRITE,0);			
+		}
+	}
+
+	return 0;
+}
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/fs.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/fs.c
new file mode 100644
index 0000000000..0958f90cce
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/fs.c
@@ -0,0 +1,503 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : fs.c                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : These are general filesystem functions, supported by the      *
+*               functions of dir.c and fat.c  file.c uses these functions     *
+*               heavily, but is not used by fs.c (not true anymore)           *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "fs.h"
+#include "fat.h"
+#include "dir.h"
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * eint16 fs_initFs(FileSystem *fs,Partition *part)
+ * Description: This functions glues the initialisation of the filesystem together.
+ * It loads the volumeID, computes the FS type and searches for the rootsector.
+ * Return value: Returns 0 on succes and -1 on error (if magic code is wrong)
+*/
+eint16 fs_initFs(FileSystem *fs,Partition *part)
+{
+	if(!fs_isValidFat(part)){
+		return(-1);
+	}
+	fs->part=part;
+	fs_loadVolumeId(fs,part);
+	if(!fs_verifySanity(fs))return(-2);
+  	fs_countDataSectors(fs);
+	fs_determineFatType(fs);
+	fs_findFirstSectorRootDir(fs);
+	fs_initCurrentDir(fs); 
+
+	return(0);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * eint16 fs_isValidFat(Partition *part)
+ * Description: This functions loads the volumeID and checks if the magic
+ * value is present.
+ * Return value: returns 0 when magic code is missing, 1 if it is there.
+*/
+eint16 fs_isValidFat(Partition *part)
+{
+	euint8 *buf;
+	
+	buf=part_getSect(part,0,IOM_MODE_READONLY|IOM_MODE_EXP_REQ); /* Load Volume label */
+	if( ex_getb16(buf+0x1FE) != 0xAA55 ){
+		return (0);
+	}
+	part_relSect(part,buf);
+	return(1);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * void fs_loadVolumeId(FileSystem *fs, Partition *part)
+ * Description: This function loads all relevant fields from the volumeid.
+*/
+void fs_loadVolumeId(FileSystem *fs, Partition *part)
+{
+	euint8 *buf;
+	
+	buf=part_getSect(part,0,IOM_MODE_READONLY|IOM_MODE_EXP_REQ);
+	
+	fs->volumeId.BytesPerSector=ex_getb16(buf+0x0B);
+	fs->volumeId.SectorsPerCluster=*((eint8*)(buf+0x0D));
+	fs->volumeId.ReservedSectorCount=ex_getb16(buf+0x0E);
+	fs->volumeId.NumberOfFats=*((eint8*)(buf+0x10));
+	fs->volumeId.RootEntryCount=ex_getb16(buf+0x11);
+	fs->volumeId.SectorCount16=ex_getb16(buf+0x13);
+	fs->volumeId.FatSectorCount16=ex_getb16(buf+0x16);
+	fs->volumeId.SectorCount32=ex_getb32(buf+0x20);
+	fs->volumeId.FatSectorCount32=ex_getb32(buf+0x24);
+	fs->volumeId.RootCluster=ex_getb32(buf+0x2C);
+	
+	part_relSect(part,buf);
+	
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * esint16 fs_verifySanity(FileSystem *fs)
+ * Description: Does some sanity calculations.
+ * Return value: 1 on success, 0 when discrepancies were found.
+*/
+esint16 fs_verifySanity(FileSystem *fs)
+{
+	esint16 sane=1; /* Sane until proven otherwise */
+	/* First check, BPS, we only support 512 */
+	if(fs->volumeId.BytesPerSector!=512)sane=0;
+	/* Check is SPC is valid (multiple of 2, and clustersize >=32KB */
+	if(!((fs->volumeId.SectorsPerCluster == 1 ) |
+	     (fs->volumeId.SectorsPerCluster == 2 ) |
+	     (fs->volumeId.SectorsPerCluster == 4 ) |
+	     (fs->volumeId.SectorsPerCluster == 8 ) |
+	     (fs->volumeId.SectorsPerCluster == 16) |
+	     (fs->volumeId.SectorsPerCluster == 32) |
+	     (fs->volumeId.SectorsPerCluster == 64) ))sane=0;
+	/* Any number of FAT's should be supported... (untested) */
+	/* There should be at least 1 reserved sector */
+	if(fs->volumeId.ReservedSectorCount==0)sane=0;
+
+	return(sane);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * void fs_countDataSectors(FileSystem *fs)
+ * Description: This functions calculates the sectorcounts, fatsectorcounts and
+ * dataclustercounts. It fills in the general fields.
+*/
+void fs_countDataSectors(FileSystem *fs)
+{
+  euint32 rootDirSectors,dataSectorCount;
+
+  rootDirSectors=((fs->volumeId.RootEntryCount*32) +
+                 (fs->volumeId.BytesPerSector - 1)) /
+                 fs->volumeId.BytesPerSector;
+
+  if(fs->volumeId.FatSectorCount16 != 0)
+  {
+    fs->FatSectorCount=fs->volumeId.FatSectorCount16;
+    fs->volumeId.FatSectorCount32=0;
+  }
+  else
+  {
+    fs->FatSectorCount=fs->volumeId.FatSectorCount32;
+    fs->volumeId.FatSectorCount16=0;
+  }
+
+  if(fs->volumeId.SectorCount16!=0)
+  {
+    fs->SectorCount=fs->volumeId.SectorCount16;
+    fs->volumeId.SectorCount32=0;
+  }
+  else
+  {
+    fs->SectorCount=fs->volumeId.SectorCount32;
+    fs->volumeId.SectorCount16=0;
+  }
+
+  dataSectorCount=fs->SectorCount - (
+                  fs->volumeId.ReservedSectorCount +
+                  (fs->volumeId.NumberOfFats * fs->FatSectorCount) +
+                  rootDirSectors);
+
+  fs->DataClusterCount=dataSectorCount/fs->volumeId.SectorsPerCluster;
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * void fs_determineFatType(FileSystem *fs)
+ * Description: This function looks af the Dataclustercount and determines the
+ * FAT type. It fills in fs->type.
+*/
+void fs_determineFatType(FileSystem *fs)
+{
+	if(fs->DataClusterCount < 4085)
+	{
+		fs->type=FAT12;
+		fs->volumeId.RootCluster=0;
+	}
+	else if(fs->DataClusterCount < 65525)
+	{
+		fs->type=FAT16;
+		fs->volumeId.RootCluster=0;
+	}
+	else
+	{
+		fs->type=FAT32;
+	}
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * void fs_findFirstSectorRootDir(FileSystem *fs)
+ * Description: This functions fills in the fs->FirstSectorRootDir field, even
+ * for FAT32, although that is not necessary (because you have FirstClusterRootDir).
+*/
+void fs_findFirstSectorRootDir(FileSystem *fs)
+{
+	if(fs->type==FAT32)
+		fs->FirstSectorRootDir = fs->volumeId.ReservedSectorCount + 
+		                         (fs->volumeId.NumberOfFats*fs->volumeId.FatSectorCount32) +
+								 (fs->volumeId.RootCluster-2)*fs->volumeId.SectorsPerCluster;
+	else
+		fs->FirstSectorRootDir = fs->volumeId.ReservedSectorCount + 
+		                         (fs->volumeId.NumberOfFats*fs->volumeId.FatSectorCount16);
+}
+/*****************************************************************************/ 
+
+void fs_initCurrentDir(FileSystem *fs)
+{
+	fs->FirstClusterCurrentDir = fs_getFirstClusterRootDir(fs);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * long fs_clusterToSector(FileSystem *fs,euint32 cluster)
+ * Description: This function converts a clusternumber in the effective sector
+ * number where this cluster starts. Boundary check is not implemented
+ * Return value: A long is returned representing the sectornumber.
+*/
+euint32 fs_clusterToSector(FileSystem *fs,euint32 cluster)
+{
+	eint32 base;
+	
+	if(fs->type==FAT32)
+	{
+		base=
+			fs->volumeId.ReservedSectorCount+
+			fs->FatSectorCount*fs->volumeId.NumberOfFats;
+	}
+	else
+	{
+		base=
+			fs->volumeId.ReservedSectorCount+
+			fs->FatSectorCount*fs->volumeId.NumberOfFats+
+			fs->volumeId.RootEntryCount/16;
+	}
+	return( base + (cluster-2)*fs->volumeId.SectorsPerCluster );
+}
+/*****************************************************************************/ 
+
+/* Function is unused, but may be usefull */
+euint32 fs_sectorToCluster(FileSystem *fs,euint32 sector)
+{
+	eint32 base;
+	
+	if(fs->type==FAT32)
+	{
+		base=
+			fs->volumeId.ReservedSectorCount+
+			fs->FatSectorCount*fs->volumeId.NumberOfFats;
+	}
+	else
+	{
+		base=
+			fs->volumeId.ReservedSectorCount+
+			fs->FatSectorCount*fs->volumeId.NumberOfFats+
+			fs->volumeId.RootEntryCount/16;
+	}
+	return(((sector-base)-((sector-base)%fs->volumeId.SectorsPerCluster))/fs->volumeId.SectorsPerCluster+2 );
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 fs_getNextFreeCluster(FileSystem *fs,euint32 startingcluster)
+ * Description: This functions searches for a free cluster, starting it's search at
+ * cluster startingcluster. This allow to speed up searches and try to avoid 
+ * fragmentation. Implementing rollover search is still to be done.
+ * Return value: If a free cluster is found it's number is returned. If none is 
+ * found 0 is returned.
+*/
+euint32 fs_getNextFreeCluster(FileSystem *fs,euint32 startingcluster)
+{
+	euint32 r;
+	
+	while(startingcluster<fs->DataClusterCount){
+		r=fat_getNextClusterAddress(fs,startingcluster,0);
+		if(r==0){
+			return(startingcluster);
+		}
+		startingcluster++;
+	}
+	return(0);
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************  
+ * euint32 fs_giveFreeClusterHint(FileSystem *fs)
+ * 
+ * Description: This function should return a clusternumber that is free or
+ * lies close before free clusters. The result MUST be checked to see if 
+ * it is free! Implementationhint: search the largest clusternumber in the
+ * files in the rootdirectory.
+ * 
+ * Return value: Returns it's best guess.
+*/
+euint32 fs_giveFreeClusterHint(FileSystem *fs)
+{
+	return(2); /* Now THIS is a hint ;) */
+}
+/*****************************************************************************/ 
+
+/* ****************************************************************************
+ * esint8 fs_findFile(FileSystem *fs,eint8* filename,FileLocation *loc,euint32 *lastDir)
+ *
+ * Description: This function looks if the given filename is on the given fs
+ * and, if found, fills in its location in loc.
+ * The function will first check if the pathname starts with a slash. If so it will
+ * set the starting directory to the rootdirectory. Else, it will take the firstcluster-
+ * currentdir (That you can change with chdir()) as startingpoint.
+ * The lastdir pointer will be the first cluster of the last directory fs_findfile
+ * enters. It starts out at the root/current dir and then traverses the path along with
+ * fs_findFile. 
+ * It is set to 0 in case of errors (like dir/dir/dir/file/dir/dir...)
+ * Return value: Returns 0 when nothing was found, 1 when the thing found
+ * was a file and 2 if the thing found was a directory.
+*/
+
+esint8 fs_findFile(FileSystem *fs,eint8* filename,FileLocation *loc,euint32 *lastDir)
+{
+	euint32 fccd,tmpclus;
+	eint8 ffname[11],*next,it=0,filefound=0;
+	
+	if(*filename=='/'){
+		fccd = fs_getFirstClusterRootDir(fs);
+		filename++;
+		if(!*filename){
+			if(lastDir)*lastDir=fccd;
+			return(2);
+		}
+	}else{
+		fccd = fs->FirstClusterCurrentDir;
+	}
+	
+	if(lastDir)*lastDir=fccd;
+	
+	while((next=file_normalToFatName(filename,ffname))!=0){
+		if((tmpclus=dir_findinDir(fs,ffname,fccd,loc,DIRFIND_FILE))==0)return(0);
+		it++;
+		if(loc->attrib&ATTR_DIRECTORY){
+			fccd = tmpclus;
+			filename = next;
+			if(lastDir)*lastDir=fccd;
+			if(filefound)*lastDir=0;
+		}else{
+			filefound=1;
+			if((file_normalToFatName(next,ffname))!=0){
+				return(0);
+			}else{
+				filename=next;	
+			}
+		}
+	}
+	
+	if(it==0)return(0);
+	if(loc->attrib&ATTR_DIRECTORY || !filefound)return(2);
+	return(1);
+}
+/*****************************************************************************/
+
+esint16 fs_findFreeFile(FileSystem *fs,eint8* filename,FileLocation *loc,euint8 mode)
+{
+	euint32 targetdir=0;
+	eint8 ffname[11];
+	
+	if(fs_findFile(fs,filename,loc,&targetdir))return(0);
+	if(!dir_getFatFileName(filename,ffname))return(0);
+	if(dir_findinDir(fs,ffname,targetdir,loc,DIRFIND_FREE)){
+		return(1);
+	}else{
+		if(dir_addCluster(fs,targetdir)){
+			return(0);
+		}else{
+			if(dir_findinDir(fs,ffname,targetdir,loc,DIRFIND_FREE)){
+				return(1);
+			}
+		}
+	}
+		
+	return(0);
+}
+/*****************************************************************************/
+
+/* ****************************************************************************  
+ * euint32 fs_getLastCluster(FileSystem *fs,ClusterChain *Cache)
+ * Description: This function searches the last cluster of a chain.
+ * Return value: The LastCluster (also stored in cache);
+*/
+euint32 fs_getLastCluster(FileSystem *fs,ClusterChain *Cache)
+{
+	if(Cache->DiscCluster==0){
+		Cache->DiscCluster=Cache->FirstCluster;
+		Cache->LogicCluster=0;
+	}
+	
+	if(Cache->LastCluster==0)
+	{
+		while(fat_getNextClusterChain(fs, Cache)==0)
+		{
+			Cache->LogicCluster+=Cache->Linear;
+			Cache->DiscCluster+=Cache->Linear;
+			Cache->Linear=0;
+		}
+	}
+	return(Cache->LastCluster);
+}
+/*****************************************************************************/
+
+euint32 fs_getFirstClusterRootDir(FileSystem *fs)
+{

+	if (fs->type == FAT32) 

+		return fs->volumeId.RootCluster;

+	

+	return 1;
+}
+/*****************************************************************************/
+
+void fs_initClusterChain(FileSystem *fs,ClusterChain *cache,euint32 cluster_addr)
+{
+	cache->FirstCluster=cluster_addr;
+	cache->DiscCluster=cluster_addr;
+	cache->LogicCluster=0;
+	cache->LastCluster=0; /* Warning flag here */
+	cache->Linear=0;
+}
+/*****************************************************************************/
+
+void fs_setFirstClusterInDirEntry(FileRecord *rec,euint32 cluster_addr)
+{
+	rec->FirstClusterHigh=cluster_addr>>16;
+	rec->FirstClusterLow=cluster_addr&0xFFFF;
+}
+/*****************************************************************************/
+
+esint8 fs_flushFs(FileSystem *fs)
+{
+	return(part_flushPart(fs->part,0,fs->SectorCount));
+}
+/*****************************************************************************/
+
+esint8 fs_umount(FileSystem *fs)
+{
+	return(fs_flushFs(fs));
+}
+/*****************************************************************************/
+
+esint8 fs_clearCluster(FileSystem *fs,euint32 cluster)
+{
+	euint16 c;
+	euint8* buf;
+	
+	for(c=0;c<(fs->volumeId.SectorsPerCluster);c++){
+		buf = part_getSect(fs->part,fs_clusterToSector(fs,cluster)+c,IOM_MODE_READWRITE);
+		memClr(buf,512);
+		part_relSect(fs->part,buf);
+	}
+	return(0);
+}
+
+esint8 fs_getFsInfo(FileSystem *fs)
+{
+	euint8 *buf;
+		
+ 	if(!fs->type==FAT32)return(0);
+	buf = part_getSect(fs->part,FS_INFO_SECTOR,IOM_MODE_READONLY);
+	if(ex_getb32(buf+0)!=FSINFO_MAGIC_BEGIN || ex_getb32(buf+508)!=FSINFO_MAGIC_END){
+		part_relSect(fs->part,buf);
+		return(-1);
+	}
+	fs->FreeClusterCount = ex_getb32(buf+488);
+	fs->NextFreeCluster  = ex_getb32(buf+492);
+	part_relSect(fs->part,buf);
+	return(0);
+}
+
+esint8 fs_setFsInfo(FileSystem *fs)
+{
+	euint8* buf;
+
+	if(!fs->type==FAT32)return(0);
+	buf = part_getSect(fs->part,FS_INFO_SECTOR,IOM_MODE_READWRITE);
+	if(ex_getb32(buf+0)!=FSINFO_MAGIC_BEGIN || ex_getb32(buf+508)!=FSINFO_MAGIC_END){
+		part_relSect(fs->part,buf);
+		return(-1);
+	}
+	ex_setb32(buf+488,fs->FreeClusterCount);
+	ex_setb32(buf+492,fs->NextFreeCluster);
+	part_relSect(fs->part,buf);
+	return(0);
+}
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/dir.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/dir.h
new file mode 100644
index 0000000000..4e7b880a0e
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/dir.h
@@ -0,0 +1,86 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : dir.h                                                            *
+* Release  : 0.3 - devel                                                      *
+* Description : The functions of dir.c are part of fs.c, they deal with all   *
+*               the directory specific stuff.                                 *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __DDIR_H__
+#define __DDIR_H__
+
+/*****************************************************************************/
+#include "config.h"
+#include "error.h"
+#include "fat.h"
+#include "plibc.h"
+#include "types.h"
+// #include "ioman.h"

+#include "tm.h"
+#include "fs.h"
+#include <dfs_cache.h>
+/*****************************************************************************/
+
+#define ATTR_READ_ONLY  0x01
+#define ATTR_HIDDEN     0x02
+#define ATTR_SYSTEM     0x04
+#define ATTR_VOLUME_ID  0x08
+#define ATTR_DIRECTORY  0x10
+#define ATTR_ARCHIVE    0x20
+
+#define OFFSET_DE_FILENAME            0
+#define OFFSET_DE_ATTRIBUTE          11
+#define OFFSET_DE_NTRESERVED         12
+#define OFFSET_DE_CRTIMETNT          13
+#define OFFSET_DE_CREATETIME         14
+#define OFFSET_DE_CREATEDATE         16
+#define OFFSET_DE_LASTACCESSDATE     18
+#define OFFSET_DE_FIRSTCLUSTERHIGH   20
+#define OFFSET_DE_WRITETIME          22
+#define OFFSET_DE_WRITEDATE          24
+#define OFFSET_DE_FIRSTCLUSTERLOW    26
+#define OFFSET_DE_FILESIZE           28
+
+#define DIRFIND_FILE 0
+#define DIRFIND_FREE 1
+
+void dir_getFileStructure(FileSystem *fs,FileRecord *filerec,FileLocation *loc);
+void dir_createDirectoryEntry(FileSystem *fs,FileRecord *filerec,FileLocation *loc);
+void dir_createDefaultEntry(FileSystem *fs,FileRecord *filerec,eint8* fatfilename);
+void dir_setFirstCluster(FileSystem *fs,FileLocation *loc,euint32 cluster_addr);
+void dir_setFileSize(FileSystem *fs,FileLocation *loc,euint32 numbytes);
+euint32 dir_findinRoot(FileSystem *fs,eint8 * fatname, FileLocation *loc);
+euint32 dir_findinDir(FileSystem *fs, eint8 * fatname, euint32 startCluster, FileLocation *loc, euint8 mode);
+euint32 dir_findinBuf(euint8 *buf,eint8 *fatname, FileLocation *loc, euint8 mode);
+euint32 dir_findinCluster(FileSystem *fs,euint32 cluster,eint8 *fatname, FileLocation *loc, euint8 mode);
+euint32 dir_findinRootArea(FileSystem *fs,eint8* fatname, FileLocation *loc, euint8 mode);
+esint8 dir_getFatFileName(eint8* filename, eint8* fatfilename);
+esint8 dir_updateDirectoryEntry(FileSystem *fs,FileRecord *entry,FileLocation *loc);
+esint8 dir_addCluster(FileSystem *fs,euint32 firstCluster);
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fat.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fat.h
new file mode 100644
index 0000000000..3a3b169660
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fat.h
@@ -0,0 +1,64 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : fat.h                                                            *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains all the functions dealing with the FAT     *
+*               in a Microsoft FAT filesystem. It belongs under fs.c          *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __FAT_H_
+#define __FAT_H_
+
+/*****************************************************************************/
+#include "config.h"
+#include "error.h"
+#include "file.h"
+#include "debug.h"
+#include "types.h"
+/*****************************************************************************/
+
+euint32 fat_getSectorAddressFatEntry(FileSystem *fs,euint32 cluster_addr);
+euint32 fat_getNextClusterAddress(FileSystem *fs,	euint32 cluster_addr, euint16 *linear);
+void fat_setNextClusterAddress(FileSystem *fs,euint32 cluster_addr,euint32 next_cluster_addr);
+eint16 fat_isEocMarker(FileSystem *fs,euint32 fat_entry);
+euint32 fat_giveEocMarker(FileSystem *fs);
+euint32 fat_findClusterAddress(FileSystem *fs,euint32 cluster,euint32 offset, euint8 *linear);
+euint32 fat_getNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr, euint8 * buf);
+void fat_setNextClusterAddressWBuf(FileSystem *fs,euint32 cluster_addr,euint32 next_cluster_addr,euint8 * buf);
+esint16 fat_getNextClusterChain(FileSystem *fs, ClusterChain *Cache);
+void fat_bogus(void);
+esint16 fat_LogicToDiscCluster(FileSystem *fs, ClusterChain *Cache,euint32 logiccluster);
+eint16 fat_allocClusterChain(FileSystem *fs,ClusterChain *Cache,euint32 num_clusters);
+eint16 fat_unlinkClusterChain(FileSystem *fs,ClusterChain *Cache);
+euint32 fat_countClustersInChain(FileSystem *fs,euint32 firstcluster);
+euint32 fat_DiscToLogicCluster(FileSystem *fs,euint32 firstcluster,euint32 disccluster);
+void fat_ShortnameToString(const euint8* src, eint8* nm);
+
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/file.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/file.h
new file mode 100644
index 0000000000..d389ccdf20
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/file.h
@@ -0,0 +1,100 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : file.h                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions dealing with files such as:      *
+*               fopen, fread and fwrite.                                      *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __FILE_H_
+#define __FILE_H_
+
+/*****************************************************************************/
+#include "config.h"
+#include "error.h"
+#include "tm.h"
+#include "fs.h"
+#include "dir.h"
+#include "plibc.h"
+#include "debug.h"
+#include "types.h"
+#include "fat.h"
+/*****************************************************************************/
+
+/* Operation flags */
+#define EFSL_O_RDONLY		0
+#define EFSL_O_WRONLY		1
+#define EFSL_O_RDWR			2
+#define EFSL_O_APPEND		8
+
+#define FILE_STATUS_OPEN 0
+#define FILE_STATUS_WRITE 1
+
+/*****************************************************************************\
+ *                              File                                         
+ *                             ------                                        
+ * FileRecord		DirEntry		Copy of the FileRecord for this file         
+ * FileLocation	Location		Location of the direntry
+ * FileSystem		*fs				Pointer to the filesystem this file is on    
+ * FileCache		Cache			Pointer to the cache object of the file   
+ * euint8			FileStatus		Contains bitfield regarding filestatus   
+ * euint32			FilePtr			Offsetpointer for fread/fwrite functions
+ * euint32 		FileSize		Working copy of the filesize, always use this,
+ 									it is more up to date than DirEntry->FileSize,
+									which is only updated when flushing to disc.
+\*****************************************************************************/
+struct _File{
+	FileRecord DirEntry;
+	FileLocation Location; /* Location in directory!! */
+	FileSystem *fs;
+	ClusterChain Cache;
+	euint8	FileStatus;
+	euint32 FilePtr;
+	euint32 FileSize;
+	euint32 ref_count; /* Descriptor reference count */	
+};
+typedef struct _File File;
+
+
+esint8 file_fopen(File *file, FileSystem *fs,eint8 *filename, eint32 mode);
+esint8 file_fclose(File *file);
+esint32 file_setpos(File *file,euint32 pos);
+euint32 file_fread(File *file,euint32 offset, euint32 size,euint8 *buf);
+euint32 file_read (File *file,euint32 size,euint8 *buf);
+euint32 file_fwrite(File* file,euint32 offset,euint32 size,euint8* buf);
+euint32 file_write (File* file,euint32 size,euint8* buf); 
+eint8* file_normalToFatName(eint8* filename,eint8* fatfilename);
+euint8 file_validateChar(euint8 c);
+void file_initFile(File *file, FileSystem *fs, FileLocation *loc);
+eint16 file_allocClusterChain(File *file,euint32 num_clusters);
+void file_setAttr(File* file,euint8 attribute,euint8 val);
+euint8 file_getAttr(File* file,euint8 attribute);
+euint32 file_requiredCluster(File *file,euint32 offset, euint32 size);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fs.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fs.h
new file mode 100644
index 0000000000..21cc3c0852
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/fs.h
@@ -0,0 +1,201 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : fs.h                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : These are general filesystem functions, supported by the      *
+*               functions of dir.c and fat.c  file.c uses these functions     *
+*               heavily, but is not used by fs.c (not true anymore)           *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __FS_H_
+#define __FS_H_
+
+/*****************************************************************************/
+#include "config.h"
+#include "types.h"
+#include "error.h"
+#include "partition.h"
+#include "debug.h"
+#include "tm.h"
+#include "extract.h"
+/*****************************************************************************/
+
+#define FAT12 1
+#define FAT16 2
+#define FAT32 3
+
+#define FS_INFO_SECTOR 1
+#define FSINFO_MAGIC_BEGIN 0x41615252
+#define FSINFO_MAGIC_END   0xAA550000
+
+/*****************************************************************************************\
+              VolumeId
+               ------  
+* ushort BytesPerSector		Must be 512 or shit happens.
+* uchar  SectorsPerCluster	Must be multiple of 2 (1,2,4,8,16 or 32)
+* ushort ReservedSectorCount	Number of sectors after which the first FAT begins.
+* uchar	 NumberOfFats		Should be 2
+* ushort RootEntryCount		Number of filerecords the Rootdir can contain. NOT for FAT32
+* ushort SectorCount16		Number of Sectors for 12/16 bit FAT 
+* ushort FatSectorCount16	Number of Sectors for 1 FAT on FAT12/16 bit FAT's
+* ulong  SectorCount32		Number of Sectors for 32 bit FAT
+* ulong FatSectorCount32	Number of Sectors for 1 FAT on FAT32 
+* ulong RootCluster			Clusternumber of the first cluster of the RootDir on FAT 32
+This is NOT a complete volumeId copy, no direct I/O is possible.
+\*****************************************************************************************/
+struct _VolumeId{
+	euint16 BytesPerSector;
+	euint8 SectorsPerCluster;
+	euint16 ReservedSectorCount;
+	euint8 NumberOfFats;
+	euint16 RootEntryCount;
+	euint16 SectorCount16;
+	euint16 FatSectorCount16;
+	euint32 SectorCount32;
+	euint32 FatSectorCount32;
+	euint32 RootCluster;
+};
+typedef struct _VolumeId VolumeId;
+
+/**************************************************************************************************\
+              FileSystem
+               --------
+* Partition* 	part		Pointer to partition on which this FS resides.
+* VolumeId		volumeId	Contains important FS info.
+* ulong			DataClusterCount	Number of dataclusters. This number determines the FATType.
+* ulong			FatSectorCount		Number of sectors for 1 FAT, regardless of FATType
+* ulong			SectorCount			Number of sectors, regardless of FATType
+* ulong 		FirstSectorRootDir	First sector of the RootDir. 
+* uchar			type				Determines FATType (FAT12 FAT16 or FAT32 are defined)
+
+\**************************************************************************************************/
+struct _FileSystem{
+	Partition *part;
+	VolumeId volumeId;
+	euint32 DataClusterCount;
+	euint32 FatSectorCount;
+	euint32 SectorCount;
+	euint32 FirstSectorRootDir;
+	euint32 FirstClusterCurrentDir;
+	euint32 FreeClusterCount;
+	euint32 NextFreeCluster;
+	euint8 type;
+};
+typedef struct _FileSystem FileSystem;
+
+/**************************************************************************************************\              
+		FileLocation
+               ----------
+* euint32		Sector				Sector where the directoryentry of the file/directory can be found.
+* euint8		Offset				Offset (in 32byte segments) where in the sector the entry is.
+
+\**************************************************************************************************/
+struct _FileLocation{
+	euint32 Sector;
+	euint8 Offset;
+	euint8 attrib;
+};
+typedef struct _FileLocation FileLocation;
+
+/*****************************************************************************\
+*                               FileCache                                    
+*                              -----------                                   
+* This struct acts as cache for the current file. It contains the current    
+* FATPointer (next location in the FAT table), LogicCluster                  
+* (the last part of the file that was read) and DataCluster                  
+* (the last cluster that was read).     
+* euint8		Linear				For how many more clusters the file is nonfragmented
+* euint32		LogicCluster		This field determines the n'th cluster of the file as current
+* euint32		DiscCluster		If this field is 0, it means the cache is invalid. Otherwise
+									it is the clusternumber corresponding with 
+									logic(FirstCluster+LogicCluster).
+* euint32		FirstCluster		First cluster of the chain. Zero or one are invalid.
+* euint32		LastCluster		Last cluster of the chain (is not always filled in)
+\*****************************************************************************/
+struct _ClusterChain{
+	euint8 Linear;
+	esint32 LogicCluster;
+	euint32 DiscCluster;
+	euint32 FirstCluster;
+	euint32 LastCluster;
+};
+typedef struct _ClusterChain ClusterChain;
+
+/*****************************************************************************\
+*                               FileRecord                                    *
+*                              ------------                                   *
+* This struct represents a 32 byte file entry as it occurs in the data area   *
+* of the filesystem. Direct I/O is possible.                                  *
+\*****************************************************************************/
+struct _FileRecord{
+	euint8 FileName[11];
+	euint8 Attribute;
+	euint8 NTReserved;
+	euint8 MilliSecTimeStamp;
+	euint16 CreatedTime;
+	euint16 CreatedDate;
+	euint16 AccessDate;
+	euint16 FirstClusterHigh;
+	euint16 WriteTime;
+	euint16 WriteDate;
+	euint16 FirstClusterLow;
+	euint32 FileSize;
+};
+typedef struct _FileRecord FileRecord;
+
+
+eint16 fs_initFs(FileSystem *fs,Partition *part);
+eint16 fs_isValidFat(Partition *part);
+void fs_loadVolumeId(FileSystem *fs, Partition *part);
+esint16 fs_verifySanity(FileSystem *fs);
+void fs_countDataSectors(FileSystem *fs);
+void fs_determineFatType(FileSystem *fs);
+void fs_findFirstSectorRootDir(FileSystem *fs);
+void fs_initCurrentDir(FileSystem *fs);
+euint32 fs_getSectorAddressRootDir(FileSystem *fs,euint32 secref);
+euint32 fs_clusterToSector(FileSystem *fs,euint32 cluster);
+euint32 fs_sectorToCluster(FileSystem *fs,euint32 sector);
+euint32 fs_getNextFreeCluster(FileSystem *fs,euint32 startingcluster);
+euint32 fs_giveFreeClusterHint(FileSystem *fs);
+esint16 fs_findFreeFile(FileSystem *fs,eint8* filename,FileLocation *loc,euint8 mode);
+esint8 fs_findFile(FileSystem *fs,eint8* filename,FileLocation *loc,euint32 *lastDir);
+esint8 fs_findFile_broken(FileSystem *fs,eint8* filename,FileLocation *loc);
+euint32 fs_getLastCluster(FileSystem *fs,ClusterChain *Cache);
+euint32 fs_getFirstClusterRootDir(FileSystem *fs);
+euint16 fs_makeDate(void);
+euint16 fs_makeTime(void);
+void fs_setFirstClusterInDirEntry(FileRecord *rec,euint32 cluster_addr);
+void fs_initClusterChain(FileSystem *fs,ClusterChain *cache,euint32 cluster_addr);
+esint8 fs_flushFs(FileSystem *fs);
+esint8 fs_umount(FileSystem *fs);
+esint8 fs_clearCluster(FileSystem *fs,euint32 cluster);
+esint8 fs_getFsInfo(FileSystem *fs);
+esint8 fs_setFsInfo(FileSystem *fs);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ls.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ls.h
new file mode 100644
index 0000000000..c4d9701fed
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ls.h
@@ -0,0 +1,69 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ls.h                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions to list the files in a directory *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __LS_H__
+#define __LS_H__
+
+/*****************************************************************************/
+#include "config.h"
+#include "fs.h"
+#include "dir.h"
+#include "fat.h"
+/*****************************************************************************/
+
+struct _ListDirEntry{
+	euint8 FileName[LIST_MAXLENFILENAME];
+	euint32 FileSize;
+	euint8 Attribute;
+};
+typedef struct _ListDirEntry ListDirEntry;
+
+struct _DirList{
+	FileSystem *fs;
+	euint16 cEntry,rEntry;
+	/*FileRecord currentEntry;*/
+	ListDirEntry currentEntry;
+	ClusterChain Cache;
+};
+typedef struct _DirList DirList;
+
+esint8 ls_openDir(DirList *dlist,FileSystem *fs,eint8* dirname);
+esint8 ls_getNext(DirList *dlist);
+
+esint8 ls_getDirEntry(DirList *dlist);
+esint8 ls_getRealDirEntry(DirList *dlist);
+esint8 ls_getRootAreaEntry(DirList *dlist);
+esint8 ls_isValidFileEntry(ListDirEntry *entry);
+void   ls_fileEntryToDirListEntry(DirList *dlist, euint8* buf, euint16 offset);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/mkfs.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/mkfs.h
new file mode 100644
index 0000000000..b211538b46
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/mkfs.h
@@ -0,0 +1,50 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : mkfs.h                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are used for creating an empty filesystem.    *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __MKFS_H_
+#define __MKFS_H_
+
+/*****************************************************************************/
+#include "partition.h"
+#include "plibc.h"
+#include "debug.h"
+#include "types.h"
+#include "extract.h"
+#include "config.h"
+/*****************************************************************************/
+
+#define MKFS_ERR_TOOLITTLESECTORS 1
+
+esint16 mkfs_makevfat(Partition *part);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/tm.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/tm.h
new file mode 100644
index 0000000000..42b1bade08
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/tm.h
@@ -0,0 +1,74 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : time.h                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions for time support                 *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __TIME_H_
+#define __TIME_H_
+
+/*****************************************************************************/
+#include "types.h"
+/*****************************************************************************/
+
+#ifdef DATE_TIME_SUPPORT
+	#define time_getYear(void) efsl_getYear()
+	#define time_getMonth(void) efsl_getMonth()
+	#define time_getDay(void) efsl_getDay()
+	#define time_getHour(void) efsl_getHour()
+	#define time_getMinute(void) efsl_getMinute()
+	#define time_getSecond(void) efsl_getSecond()
+	#define time_getDate(void) fs_makeDate()
+	#define time_getTime(void) fs_makeTime()
+#else
+	#define time_getYear(void) 0x0;
+	#define time_getMonth(void) 0x0;
+	#define time_getDay(void) 0x0;
+	#define time_getHour(void) 0x0;
+	#define time_getMinute(void) 0x0;
+	#define time_getSecond(void) 0x0;
+	#define time_getDate(void) 0x0;
+	#define time_getTime(void) 0x0;
+#endif
+
+#ifdef DATE_TIME_SUPPORT
+euint16 efsl_getYear(void);
+euint8  efsl_getMonth(void);
+euint8  efsl_getDay(void);
+euint8  efsl_getHour(void);
+euint8  efsl_getMinute(void);
+euint8  efsl_getSecond(void);
+euint16 fs_makeDate(void);
+euint16 fs_makeTime(void);
+#endif
+
+euint8 fs_hasTimeSupport(void);
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ui.h b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ui.h
new file mode 100644
index 0000000000..bf4d64358d
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/include/ui.h
@@ -0,0 +1,50 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ui.h                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions which will be presented to the   *
+*               user of this library.                                         *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __UI_H__
+#define __UI_H__
+
+/*****************************************************************************/
+#include "fs.h"
+#include "types.h"
+#include "fat.h"
+#include "dir.h"
+#include "config.h"
+/*****************************************************************************/
+
+esint8 mk_dir(FileSystem *fs,eint8* dirname);
+esint16 un_link(FileSystem *fs,euint8* filename);
+
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/ls.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/ls.c
new file mode 100644
index 0000000000..c203a0cd4c
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/ls.c
@@ -0,0 +1,150 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ls.c                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions to list the files in a directory *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include <dfs_fs.h>
+
+#include "ls.h"
+/*****************************************************************************/
+
+esint8 ls_openDir(DirList *dlist,FileSystem *fs,eint8* dirname)
+{
+	FileLocation loc;
+	euint32 fc;
+	esint8 result;
+	
+	dlist->fs=fs;
+
+	result = fs_findFile(dlist->fs,dirname,&loc,&fc);
+	
+	if(result == 2)
+	{
+		fs_initClusterChain(dlist->fs,&(dlist->Cache),fc);
+		memClr(&(dlist->currentEntry),sizeof(dlist->currentEntry));
+		dlist->rEntry=0;
+		dlist->cEntry=0xFFFF;
+			
+		return(0);
+	}
+	else if(result == 1)
+		dfs_log(DFS_DEBUG_INFO, ("%s is not a directory", dirname));
+	else	
+		dfs_log(DFS_DEBUG_INFO, ("can't find %s", dirname));
+	
+	return (-1);
+}
+/*****************************************************************************/
+
+esint8 ls_getDirEntry(DirList *dlist)
+{
+	if(dlist->Cache.FirstCluster == 1){
+		return(ls_getRootAreaEntry(dlist));
+	}else if(dlist->Cache.FirstCluster){
+		return(ls_getRealDirEntry(dlist));
+	}
+	return(-1);
+}
+/*****************************************************************************/
+
+esint8 ls_getNext(DirList *dlist)
+{
+	do{
+		if(ls_getDirEntry(dlist))return(-1);
+		dlist->rEntry++;
+	}while(!ls_isValidFileEntry(&(dlist->currentEntry)));
+	dlist->cEntry++;
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ls_getRealDirEntry(DirList *dlist)
+{
+	euint8* buf;
+	
+	if(dlist->Cache.FirstCluster<=1)return(-1);
+	
+	if(fat_LogicToDiscCluster(dlist->fs,
+						   &(dlist->Cache),
+						   (dlist->rEntry)/(16 * dlist->fs->volumeId.SectorsPerCluster))){
+		return(-1);
+	}
+	
+	buf = part_getSect(dlist->fs->part,
+					   fs_clusterToSector(dlist->fs,dlist->Cache.DiscCluster) + (dlist->rEntry/16)%dlist->fs->volumeId.SectorsPerCluster,
+				       IOM_MODE_READONLY);
+	
+	/*memCpy(buf+(dlist->rEntry%16)*32,&(dlist->currentEntry),32);*/
+	ls_fileEntryToDirListEntry(dlist,buf,32*(dlist->rEntry%16));
+	
+	part_relSect(dlist->fs->part,buf);
+	
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ls_getRootAreaEntry(DirList *dlist)
+{
+	euint8 *buf=0;
+	
+	if((dlist->fs->type != FAT12) && (dlist->fs->type != FAT16))return(-1);
+	if(dlist->rEntry>=dlist->fs->volumeId.RootEntryCount)return(-1);
+	
+	buf = part_getSect(dlist->fs->part,
+					   dlist->fs->FirstSectorRootDir+dlist->rEntry/16,
+					   IOM_MODE_READONLY);
+	/*memCpy(buf+32*(dlist->rEntry%16),&(dlist->currentEntry),32);*/
+	ls_fileEntryToDirListEntry(dlist,buf,32*(dlist->rEntry%16));
+	part_relSect(dlist->fs->part,buf);
+	return(0);
+}
+/*****************************************************************************/
+
+esint8 ls_isValidFileEntry(ListDirEntry *entry)
+{
+	if(entry->FileName[0] == 0 || entry->FileName[0] == 0xE5 || entry->FileName[0] == '.')return(0);
+	if((entry->Attribute&0x0F)==0x0F)return(0);
+ 	return(1);
+}
+/*****************************************************************************/
+
+void ls_fileEntryToDirListEntry(DirList *dlist, euint8* buf, euint16 offset)
+{
+	if(offset>480 || offset%32)return;
+	
+	buf+=offset;
+	memCpy(buf+OFFSET_DE_FILENAME,dlist->currentEntry.FileName,LIST_MAXLENFILENAME);
+	dlist->currentEntry.Attribute = *(buf+OFFSET_DE_ATTRIBUTE);
+	dlist->currentEntry.FileSize = ex_getb32(buf+OFFSET_DE_FILESIZE);
+}
+/*****************************************************************************/
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/mkfs.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/mkfs.c
new file mode 100644
index 0000000000..e19e2468ea
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/mkfs.c
@@ -0,0 +1,166 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : mkfs.c                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : These functions are used for creating an empty filesystem.    *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "mkfs.h"
+/*****************************************************************************/
+
+esint16 mkfs_makevfat(Partition *part)
+{
+	unsigned long c,cc,ret;
+	unsigned long ns,fs,ds,dc;
+	unsigned char buf[512];
+	
+	ns=part->disc->partitions[part->activePartition].numSectors;
+	
+	if( ns < 66581 ){
+		DBG((TXT("This is not possible due to insufficient sectors. Sorry\n")));
+		return(MKFS_ERR_TOOLITTLESECTORS);
+	}
+	
+	ret=0;
+	
+	for(c=1<<6;c>=1;c>>=1){
+		
+		/* First guess */
+		ds = ns - 32;
+		fs = ((ds/c)+127)/128;
+		/* ds was guess too large, so fs is too large now too. */
+		
+		for(cc=0;cc<2;cc++){
+		
+			/* Round 2, error round */
+			ds = ns - 32 - 2*fs;
+			fs = ((ds/c)+127)/128; 
+			/* Since fs was too large, ds became too small. So the fs for this small ds is too small as well. */
+			
+			/* Round 3, correction round */
+			ds = ns - 32 - 2*fs;
+			fs = ((ds/c)+127)/128; 
+			/* The fs was too small, so ds was too large. The calculated fs should be slightly too large. */
+		
+		}
+		
+		/* Round 4, finalise */
+		ds = ns - 32 - 2*fs; 
+
+		dc = ds / c;
+		if(ret<(fs*128-dc)/128)ret=(fs*128-dc)/128;
+		
+		/* Check if with current setting we have a valid fat ? */
+		
+		if(dc >= 65525 + 16){
+			break;
+		}
+	}
+
+	/* Generate BPB */
+	memClr(buf,512);
+	
+	/* Boot code */
+	*(buf+0)=0xE9;	*(buf+1)=0x00;	*(buf+2)=0x00; /* RESET */
+	
+	/* OEM name */
+	memCpy("DSCOSMSH",buf+3,8);
+	
+	/* Bytes/Sector */
+	/* *((unsigned short*)(buf+11)) = 512; */
+	ex_setb16(buf+11,512);
+	
+	/* Sectors/Cluster */
+	*(buf+13) = c;
+	
+	/* Reserved Sectors */
+	/* *((unsigned short*)(buf+14)) = 32; */
+	ex_setb16(buf+14,32);
+	
+	/* Number of FAT Tables */
+	*(buf+16) = 2;
+	
+	/* RootEntryCount */
+	/* *((unsigned short*)(buf+17)) = 0; */
+	ex_setb16(buf+17,0);
+	
+	/* Total Sector Count __16 */
+	/* *((unsigned short*)(buf+19)) = 0; */
+	ex_setb16(buf+19,0);
+	
+	/* Media (crap) */
+	*(buf+21) = 0xF8;
+	
+	/* FAT size 16 */
+	/* *((unsigned short*)(buf+22)) = 0; */
+	ex_setb16(buf+22,0);
+	
+	/* Total Sector Count __32 */
+	/* *((unsigned long*)(buf+32)) = ns; */
+	ex_setb32(buf+32,ns);
+	
+	/* Fat Size 32 */
+	/* *((unsigned long*)(buf+36)) = fs; */
+	ex_setb32(buf+36,fs);
+	
+	/* First Cluster Root Dir */
+	/* *((unsigned long*)(buf+44)) = 2; */
+	ex_setb32(buf+44,2);
+	
+	/* VolumeID */
+	/* *((unsigned long*)(buf+67)) = 0x13371337; */
+	ex_setb32(buf+67,0);
+	
+	/* Volume Label */
+	memCpy("EFSL-0.3.3 ",buf+71,11);

+	
+	/* Filesystemtype */
+	memCpy("FAT32   ",buf+82,8);
+	
+	/* Magic */
+	*(buf+510) = 0x55; *(buf+511) = 0xAA;
+	
+	part_writeBuf(part,0,buf);
+	
+	memClr(buf,512);
+	for(c=32;c<(32+2*fs);c++){
+		part_writeBuf(part,c,buf);
+	}
+	/* *(((unsigned long*)buf)  )=0x0FFFFFF8;
+	*(((unsigned long*)buf)+1)=0x0FFFFFFF;
+	*(((unsigned long*)buf)+2)=0x0FFFFFF8; */
+	ex_setb32(buf+0,(euint32)0x0FFFFFF8);
+	ex_setb32(buf+4,(euint32)0x0FFFFFFF);
+	ex_setb32(buf+8,(euint32)0x0FFFFFF8);
+	part_writeBuf(part,32,buf);
+	part_writeBuf(part,32+fs,buf);
+	
+	return(0);
+}
\ No newline at end of file
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/time.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/time.c
new file mode 100644
index 0000000000..f5ab55f865
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/time.c
@@ -0,0 +1,89 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : time.c                                                           *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions for time support                 *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "tm.h"
+/*****************************************************************************/
+
+euint16 fs_makeDate(void)
+{
+#ifndef DATE_TIME_SUPPORT
+	return(0);
+#else
+	euint8 m,d;
+	euint16 y;
+	
+	y = time_getYear()-1980;
+	m = time_getMonth();
+	d = time_getDay();
+	
+	return(
+		(y>127?127<<9:(y&0x3F)<<9)   |
+		((m==0||m>12)?1:(m&0xF)<<5)  |
+		((d==0||d>31)?1:(d&0x1F))
+	);
+#endif
+}
+/*****************************************************************************/
+
+euint16 fs_makeTime(void)
+{
+#ifndef DATE_TIME_SUPPORT
+	return(0);
+#else
+	euint8 s,m,h;
+	
+	s = time_getSecond();
+	m = time_getMinute();
+	h = time_getHour();
+	
+	return(
+		(h>23?0:(h&0x1F)<<11) |
+		(m>59?0:(m&0x3F)<<5)  |
+		(s>59?0:(s-s%2)/2)
+	);
+#endif
+}
+/*****************************************************************************/
+
+euint8 fs_hasTimeSupport(void)
+{
+#ifdef DATE_TIME_SUPPORT
+	return(1);
+#else
+	return(0);
+#endif
+}
+/*****************************************************************************/
+
+
diff --git a/filesystem/dfs/filesystems/efsl/src/fs/vfat/ui.c b/filesystem/dfs/filesystems/efsl/src/fs/vfat/ui.c
new file mode 100644
index 0000000000..b37e0397e2
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/fs/vfat/ui.c
@@ -0,0 +1,200 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ui.c                                                             *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains functions which will be presented to the   *
+*               user of this library.                                         *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+/*****************************************************************************/
+#include "ui.h"
+#include "ls.h"
+#include "efs.h"

+/*****************************************************************************/
+
+/* ****************************************************************************  
+* unlink dir or [email protected],2008-08-19 
+*/
+esint16 un_link(FileSystem *fs,euint8* filename)
+{
+	FileLocation loc;
+	ClusterChain cache;
+	DirList *dlist;	
+	euint8* buf;
+	euint8 attr;
+	euint32 firstCluster=0;
+	euint32 fc;
+
+	if ( filename[0] == '/' && filename[1] == '\0')
+	{
+		/* it's the root directory */
+		dfs_log(DFS_DEBUG_INFO, ("Can't delete root directory"));
+		return -DFS_STATUS_EISDIR;
+	}
+	
+	if((fs_findFile(fs,(eint8*)filename,&loc,&fc)) > 0)
+	{
+		buf = part_getSect(fs->part,loc.Sector,IOM_MODE_READWRITE);
+		firstCluster = ex_getb16(buf+loc.Offset*32+20);
+		firstCluster <<= 16;
+		firstCluster += ex_getb16(buf+loc.Offset*32+26);
+		attr = ex_getb16(buf+loc.Offset*32+11);
+		if(attr == ATTR_DIRECTORY)
+		{
+			dlist = (DirList *)rt_malloc(sizeof(DirList));
+			if(dlist == RT_NULL)
+			{
+				part_relSect(fs->part,buf);
+				
+				dfs_log(DFS_DEBUG_INFO, ("Memory alloc failed"));				
+				return -DFS_STATUS_ENOMEM;	
+			}
+			
+			if(firstCluster != 0)
+			{
+				dlist->fs = fs;
+				fs_initClusterChain(fs,&(dlist->Cache),fc);
+				memClr(&(dlist->currentEntry),sizeof(dlist->currentEntry));
+				dlist->rEntry = 0;
+				dlist->cEntry = 0xFFFF;
+
+				while(1)
+				{
+					/* it's the end of file */
+					if(ls_getNext(dlist) == 0) 
+					{
+						/* '.' and '..' */
+						if(dlist->currentEntry.FileName[0] == '.') continue;
+						
+						part_relSect(fs->part,buf);
+						
+						dfs_log(DFS_DEBUG_INFO, ("Directory not empty"));
+						return -DFS_STATUS_ENOTEMPTY;
+					}
+					else break;
+				}
+			}
+		}
+
+		memClr(buf+(loc.Offset*32),32);
+		part_relSect(fs->part,buf);
+		cache.DiscCluster = cache.LastCluster = cache.Linear = cache.LogicCluster = 0;
+		cache.FirstCluster = firstCluster;
+ 		fat_unlinkClusterChain(fs,&cache);
+		
+		return 0;
+	}
+	return -DFS_STATUS_ENOENT;
+}
+
+/*****************************************************************************/
+esint8 mk_dir(FileSystem *fs,eint8* dirname)
+{
+	FileLocation loc;
+	FileRecord direntry;
+	euint32 nc,parentdir;
+	euint8* buf;
+	eint8 ffname[11];
+	
+	if( fs_findFile(fs,dirname,&loc,&parentdir) )
+	{
+		dfs_log(DFS_DEBUG_INFO, ("directory %s has existed", dirname));		
+		return(-1);
+	}
+	if(parentdir==0)
+	{
+		dfs_log(DFS_DEBUG_INFO, ("parent directory doesn't existe"));
+		return(-2);
+	}	
+	
+	if(!fs_findFreeFile(fs,dirname,&loc,0))
+	{
+		dfs_log(DFS_DEBUG_INFO, ("can't find free entry"));
+		return(-3);
+	}	
+	
+	/* You may never search for a free cluster, and the call
+	 * functions that may cause changes to the FAT table, that
+	 * is why getNextFreeCluster has to be called AFTER calling
+	 * fs_findFreeFile, which may have to expand a directory in
+	 * order to store the new filerecord !! 
+	 */
+	
+	nc = fs_getNextFreeCluster(fs,fs_giveFreeClusterHint(fs));
+	if(nc==0)
+	{
+		dfs_log(DFS_DEBUG_INFO, ("no free cluster"));		
+		return(0);
+	}
+	
+	fs_clearCluster(fs,nc);
+	
+	buf = part_getSect(fs->part,loc.Sector,IOM_MODE_READWRITE);
+
+	dir_getFatFileName(dirname,ffname);
+	memClr(&direntry,sizeof(direntry));
+	memCpy(ffname,&direntry,11);
+	direntry.FileSize = 0;
+	direntry.FirstClusterHigh=nc>>16;
+	direntry.FirstClusterLow=nc&0xFFFF;
+	direntry.Attribute = ATTR_DIRECTORY;
+	memCpy(&direntry,buf+(32*loc.Offset),32);
+		
+	part_relSect(fs->part,buf);
+	
+	buf = part_getSect(fs->part,fs_clusterToSector(fs,nc),IOM_MODE_READWRITE);
+	
+	memClr(&direntry,sizeof(direntry));
+	memCpy(".          ",&direntry,11);
+	direntry.Attribute = ATTR_DIRECTORY;
+	direntry.FileSize = 0;
+	direntry.FirstClusterHigh=nc>>16;
+	direntry.FirstClusterLow=nc&0xFFFF;
+	memCpy(&direntry,buf,32);
+	
+	if(fs->type == FAT32 && parentdir == fs->volumeId.RootCluster)
+		parentdir = 0;
+	
+	if(fs->type != FAT32 && parentdir<=1)
+		parentdir = 0;
+	
+	memClr(&direntry,sizeof(direntry));
+	memCpy("..         ",&direntry,11);
+	direntry.Attribute = ATTR_DIRECTORY;
+	direntry.FileSize = 0;
+	direntry.FirstClusterHigh=parentdir>>16;
+	direntry.FirstClusterLow=parentdir&0xFFFF;
+	memCpy(&direntry,buf+32,32);
+
+	part_relSect(fs->part,buf);
+	
+	fat_setNextClusterAddress(fs,nc,fat_giveEocMarker(fs));
+
+	return(0);
+}
diff --git a/filesystem/dfs/filesystems/efsl/src/include/config.h b/filesystem/dfs/filesystems/efsl/src/include/config.h
new file mode 100644
index 0000000000..f4e296b18a
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/include/config.h
@@ -0,0 +1,151 @@
+#ifndef __EFSL_CONFIG_H__

+#define __EFSL_CONFIG_H__

+

+/* Hardware target

+   ---------------

+

+ * Here you will define for what hardware-endpoint EFSL should be compiled.

+ * Look in interfaces.h to see what systems are supported, and add your own

+ * there if you need to write your own driver. Then, define the name you

+ * selected for your hardware there here. Make sure that you only select one

+ * device!

+*/

+

+	/*#define HW_ENDPOINT_LINUX*/

+	/*#define HW_ENDPOINT_ATMEGA128_SD*/

+	/*#define HW_ENDPOINT_DSP_TI6713_SD*/

+

+#define MULTIPLE_INTERFACE_SUPPORT

+/*#define HWIFUNC_INIT(x)      lf_init(x)

+#define HWIFUNC_READ(x,y,z)  lf_readBuf(x,y,z)

+#define HWIFUNC_WRITE(x,y,z) lf_writeBuf(x,y,z)

+#define HWIFUNC_HEADER interfaces/linuxfile.h */

+

+/* Architecture

+   ------------

+

+ * In this section you should configure how large the default variable

+ * types in your system are. This is controlled in types.h in the general

+ * include directory. The selection you make here defines to what the various

+ * e(s|u)int(8,16,32) types will map.

+ * For 32 bit Linux : VARSIZE_LINUX32

+ * For 64 bit Linux : VARSIZE_LINUX64

+ * For AVR's        : VARSIZE_ATMEGA

+ * For TMS67XX      : VARSIZE_TMS67XX

+ */

+

+#define VARSIZE_LINUX32

+

+/* Memory configuration

+   --------------------

+

+ * Here you must configure wheter your processor can access memory byte

+ * oriented. All x86 processors can do it, AVR's can do it to. Some DSP

+ * or other microcontrollers can't. If you have an 8 bit system you're safe.

+ * If you are really unsure, leave the setting commented out, it will be slower

+ * but it will work for sure.

+*/

+

+#define BYTE_ALIGNMENT

+

+/* Cache configuration

+   -------------------

+

+ * Here you must configure how much memory of cache you can/want to use.

+ * The number you put at IOMAN_NUMBUFFER is multiplied by 512. So 1 means

+ * 512 bytes cache, 4 means 2048 bytes cache. More is better.

+ * The number after IOMAN_NUMITERATIONS should be untouched.

+ * The last field (IOMAN_DO_MEMALLOC) is to tell ioman to allocate it's

+ * own memory in it's structure, or not. If you choose to do it yourself

+ * you will have to pass a pointer to the memory as the last argument of

+ * ioman_init.

+*/

+	#define IOMAN_NUMBUFFER 10

+	#define IOMAN_NUMITERATIONS 3

+	#define IOMAN_DO_MEMALLOC

+

+/* Cluster pre-allocation

+   ----------------------

+

+ * When writing files, the function that performs the actual write has to

+ * calculate how many clusters it will need for that request. It then allocates

+ * that number of new clusters to the file. Since this involves some

+ * calculations and writing of the FAT, you might find it beneficial to limit

+ * the number of allocations, and allow fwrite to pre-allocate a number of

+ * clusters extra. This setting determines how many clusters will be extra

+ * allocated whenever this is required.

+ * Take in carefull consideration how large your clustersize is, putting 10 here

+ * with a clustersize of 32kb means you might waste 320 kb.

+ * The first option is for preallocating files, the other is used when enlarging

+ * a directory to accomodate more files

+*/

+      #define CLUSTER_PREALLOC_FILE 5

+      #define CLUSTER_PREALLOC_DIRECTORY 2

+

+/* Endianess configuration

+   -----------------------

+

+ * Here you can configure wheter your architecture is little or big endian. This

+ * is important since all FAT structures are stored in intel little endian

+ * order. So if you have a big endian system the library has to convert all

+ * figures to big endian in order to work.

+ */

+	/*#define HOST_BIG_ENDIAN*/

+	#define HOST_LITTLE_ENDIAN

+

+/* Date and Time support

+   ---------------------

+

+ * Here you can enable or disable date and time support. If you enable

+ * it you will have to create 6 functions, that are described in the

+ * EFSL manual. If the functions are not present when linking your

+ * program with the library you will get unresolved dependencies.

+ */

+ 	/* #define DATE_TIME_SUPPORT */

+

+/* Error reporting support

+   -----------------------

+

+ * When you receive an error in userland, it usually only gives limited

+ * information (most likely, fail or success). If error detection and

+ * reporting is important for you, you can enable more detailed error

+ * reporting here. This is optional, the costs are 1 byte per object,

+ * and a small increase in code size.

+ * You can enable error recording for all object, or you can select the

+ * object manually.

+ * For full error reporting use FULL_ERROR_SUPPORT

+ * For only the base-core of the library use BASE_ERROR_SUPPORT

+ * For IO/Man use ERRSUP_IOMAN

+ * For Disc   use ERRSUP_IOMAN

+ * For Part   use ERRSUP_PARTITION

+ * For Fs     use ERRSUP_FILESYSTEM

+ * For File   use ERRSUP_FILE

+*/

+

+	#define FULL_ERROR_SUPPORT

+	/*#define BASE_ERROR_SUPPORT*/

+

+

+/* Debugging configuration

+   -----------------------

+

+ * Here you can configure the debugging behaviour. Debugging is different

+ * on every platform (see debug.h for more information).

+ * If your hardware has no means of output (printf) dont define any anything,

+ * and nothing will happen. For real world use debugging should be turned off.

+*/

+

+	/*#define DEBUG*/

+	/*#define DO_FUNC_DEBUG*/

+

+/* List options

+   ------------

+

+ * In this section you can configure what kind of data you will get from

+ * directory listing requests. Please refer to the documentation for

+ * more information

+*/

+

+	#define LIST_MAXLENFILENAME 12

+

+#endif

diff --git a/filesystem/dfs/filesystems/efsl/src/include/error.h b/filesystem/dfs/filesystems/efsl/src/include/error.h
new file mode 100644
index 0000000000..7dec992a29
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/include/error.h
@@ -0,0 +1,124 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : error.h                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : Header file containing error-defines.                         *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __ERROR_H_
+#define __ERROR_H_
+
+/*****************************************************************************/
+#include "config.h"
+/*****************************************************************************/
+
+#if defined (FULL_ERROR_SUPPORT)
+	#define ERRSUP_IOMAN
+	#define ERRSUP_DISC
+	#define ERRSUP_PARTITION
+	#define ERRSUP_FAT_FILESYSTEM
+	#define ERRSUP_FAT_FILESYSTEM
+#elif defined (BASE_ERROR_SUPPORT)
+	#define ERRSUP_IOMAN
+	#define ERRSUP_DISC
+	#define ERRSUP_PARTITION
+#endif
+
+#if defined (HWINT_HAS_ERROR_SUPPORT) && defined (INTERFACE_ERROR_SUPPORT)
+	#define ERRSUP_HWINTERFACE
+#endif
+
+#ifdef ERRSUP_IOMAN
+	#define IOMAN_ERR_EUINT8 euint8 error;
+	#define ioman_setError(ioman,errval) ioman->error = errval
+	#define ioman_getError(ioman)        ioman->error
+#else
+	#define IOMAN_ERR_EUINT8 
+	#define ioman_setError(ioman,errval) 
+	#define ioman_getError(ioman) 0
+#endif
+
+#ifdef ERRSUP_DISC
+	#define DISC_ERR_EUINT8 euint8 error;
+	#define disc_setError(disc,errval) disc->error = errval
+	#define disc_getError(disc)        disc->error
+#else
+	#define DISC_ERR_EUINT8 
+	#define disc_setError(disc,errval) 
+	#define disc_getError(disc) 0
+#endif
+
+#ifdef ERRSUP_PART
+	#define PART_ERR_EUINT8 euint8 error;
+	#define part_setError(part,errval) part->error = errval
+	#define part_getError(part)        part->error
+#else
+	#define PART_ERR_EUINT8 
+	#define part_setError(part,errval) 
+	#define part_getError(part) 0
+#endif
+
+#ifdef ERRSUP_FAT_FILESYSTEM
+	#define FILESYSTEM_ERR_EUINT8 euint8 error;
+	#define fs_setError(fs,errval) fs->error = errval
+	#define fs_getError(fs)        fs->error
+#else
+	#define FILESYSTEM_ERR_EUINT8 
+	#define fs_setError(fs,errval) 
+	#define fs_getError(fs) 0
+#endif
+
+#ifdef ERRSUP_FILE
+	#define FILE_ERR_EUINT8 euint8 error;
+	#define file_setError(file,errval) file->error = errval
+	#define file_getError(file)        file->error
+#else
+	#define FILE_ERR_EUINT8 
+	#define file_setError(file,errval) 
+	#define file_getError(file) 0
+#endif
+
+#define IOMAN_NOERROR                     0
+#define IOMAN_ERR_SETATTROUTOFBOUNDS      1
+#define IOMAN_ERR_GETATTROUTOFBOUNDS      2
+#define IOMAN_ERR_READFAIL                3
+#define IOMAN_ERR_WRITEFAIL               4
+#define IOMAN_ERR_OPOUTOFBOUNDS           5
+#define IOMAN_ERR_PUSHBEYONDSTACK         6
+#define IOMAN_ERR_POPEMPTYSTACK           7
+#define IOMAN_ERR_CACHEPTROUTOFRANGE      8
+#define IOMAN_ERR_WRITEREADONLYSECTOR     9
+#define IOMAN_ERR_NOMEMORY                10
+
+#define DISC_NOERROR                      0
+
+#define PART_NOERROR                      0
+
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/include/ioctl.h b/filesystem/dfs/filesystems/efsl/src/include/ioctl.h
new file mode 100644
index 0000000000..93a0b947a7
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/include/ioctl.h
@@ -0,0 +1,44 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : ioctl.h                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains the ioctl command numbers                  *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __EFS_IOCTL_H__
+#define __EFS_IOCTL_H__
+
+/*****************************************************************************/
+#include "config.h"
+/*****************************************************************************/
+
+#define IOCTL_NOP 				0
+#define IOCTL_SECTORCOUNT 			1
+
+#endif
diff --git a/filesystem/dfs/filesystems/efsl/src/include/types.h b/filesystem/dfs/filesystems/efsl/src/include/types.h
new file mode 100644
index 0000000000..6e05e6239f
--- /dev/null
+++ b/filesystem/dfs/filesystems/efsl/src/include/types.h
@@ -0,0 +1,110 @@
+/*****************************************************************************\
+*                     EFSL - Embedded Filesystems Library                     *
+*                     -----------------------------------                     *
+*                                                                             *
+* Filename : types.h                                                          *
+* Release  : 0.3 - devel                                                      *
+* Description : This file contains the crossplatform data types               *
+*                                                                             *
+* This program is free software; you can redistribute it and/or               *
+* modify it under the terms of the GNU General Public License                 *
+* as published by the Free Software Foundation; version 2                     *
+* of the License.                                                             *
+*                                                                             *
+* 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.                                *
+*                                                                             *
+* As a special exception, if other files instantiate templates or             *
+* use macros or inline functions from this file, or you compile this          *
+* file and link it with other works to produce a work based on this file,     *
+* this file does not by itself cause the resulting work to be covered         *
+* by the GNU General Public License. However the source code for this         *
+* file must still be made available in accordance with section (3) of         *
+* the GNU General Public License.                                             *
+*                                                                             *
+* This exception does not invalidate any other reasons why a work based       *
+* on this file might be covered by the GNU General Public License.            *
+*                                                                             *
+*                                                    (c)2006 Lennart Yseboodt *
+*                                                    (c)2006 Michael De Nil   *
+\*****************************************************************************/
+
+#ifndef __EFS_TYPES_H__
+#define __EFS_TYPES_H__
+
+/*****************************************************************************/
+#include "config.h"
+/*****************************************************************************/
+
+/* VARIABLE SIZES
+   ==============
+   
+   * eint8   -> 1 byte
+   * eint16  -> 2 bytes
+   * eint32  -> 4 bytes
+   *
+   * VARSIZE_LINUX32 is suitable for 32bit Linux
+   * VARSIZE_LINUX64 is suitable for 64bit Linux
+   * VARSIZE_ATMEGA  is suitable for AVR's
+   * VARSIZE_TMS67XX is suitable for the TI TMS67XX
+   *
+   * If nothing is selected a default is used, that should work on
+   * 32 bit systems
+   */
+
+#if defined(VARSIZE_LINUX32)
+	typedef char eint8;
+	typedef signed char esint8;
+	typedef unsigned char euint8;
+	typedef short eint16;
+	typedef signed short esint16;
+	typedef unsigned short euint16; 
+	typedef long eint32; 
+	typedef signed long esint32;
+	typedef unsigned long euint32; 
+#elif defined(VARSIZE_LINUX64)
+	typedef char eint8;
+	typedef signed char esint8;
+	typedef unsigned char euint8;
+	typedef short eint16;
+	typedef signed short esint16;
+	typedef unsigned short euint16;
+	typedef int eint32;
+	typedef signed int esint32;
+	typedef unsigned int euint32;
+#elif defined (VARSIZE_ATMEGA)
+	typedef char eint8;
+	typedef signed char esint8;
+	typedef unsigned char euint8;
+	typedef short eint16;
+	typedef signed short esint16;
+	typedef unsigned short euint16; 
+	typedef long eint32; 
+	typedef signed long esint32;
+	typedef unsigned long euint32; 
+#elif defined(VARSIZE_TMS67XX)
+	typedef char eint8;
+	typedef signed char esint8;
+	typedef unsigned char euint8;
+	typedef short eint16;
+	typedef signed short esint16;
+	typedef unsigned short euint16; 
+	typedef int eint32; 
+	typedef signed int esint32;
+	typedef unsigned int euint32; 
+#else
+#warning "No VARSIZE selection has been made, beware!"
+	typedef char eint8;
+	typedef signed char esint8;
+	typedef unsigned char euint8;
+	typedef short eint16;
+	typedef signed short esint16;
+	typedef unsigned short euint16; 
+	typedef long eint32; 
+	typedef signed long esint32;
+	typedef unsigned long euint32; 
+#endif
+
+#endif
diff --git a/filesystem/dfs/include/dfs_cache.h b/filesystem/dfs/include/dfs_cache.h
new file mode 100644
index 0000000000..4321664e23
--- /dev/null
+++ b/filesystem/dfs/include/dfs_cache.h
@@ -0,0 +1,41 @@
+#ifndef __DFS_CACHE_H__

+#define __DFS_CACHE_H__

+

+#include <rtthread.h>

+

+#define IOMAN_STATUS_ATTR_VALIDDATA  0

+#define IOMAN_STATUS_ATTR_USERBUFFER 1

+#define IOMAN_STATUS_ATTR_WRITE      2

+

+#define IOM_MODE_READONLY  1

+#define IOM_MODE_READWRITE 2

+#define IOM_MODE_EXP_REQ   4

+

+#define DFS_SECTOR_SIZE     512

+

+struct _IOManager

+{

+	rt_device_t device;

+	rt_uint8_t  numbuf;

+	

+    rt_uint32_t sector[DFS_CACHE_MAX_NUM];

+	rt_uint8_t  status[DFS_CACHE_MAX_NUM];

+	rt_uint8_t  usage [DFS_CACHE_MAX_NUM];

+

+    /* cache FIFO */

+    rt_uint8_t  ring_fifo[DFS_CACHE_MAX_NUM];

+

+    /* cache buffer */

+    rt_uint8_t  cache[DFS_CACHE_MAX_NUM][DFS_SECTOR_SIZE];

+};

+typedef struct _IOManager IOManager;

+

+rt_err_t ioman_init(IOManager* ioman);
+rt_uint8_t* ioman_getSector(IOManager *ioman, rt_uint32_t address, rt_uint8_t mode);
+rt_err_t ioman_releaseSector(IOManager *ioman, rt_uint8_t* buf);
+rt_err_t ioman_flushRange(IOManager *ioman, rt_uint32_t address_low, rt_uint32_t address_high);

+
+rt_err_t ioman_directSectorRead(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf, rt_uint32_t numsector);
+rt_err_t ioman_directSectorWrite(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf, rt_uint32_t numsector);
+
+#endif

diff --git a/filesystem/dfs/include/dfs_def.h b/filesystem/dfs/include/dfs_def.h
new file mode 100644
index 0000000000..27b05e20e0
--- /dev/null
+++ b/filesystem/dfs/include/dfs_def.h
@@ -0,0 +1,173 @@
+/*
++------------------------------------------------------------------------------
+|        Device FileSystem
++------------------------------------------------------------------------------
+| Copyright 2004, 2005  www.fayfayspace.org.
+| All rights reserved.
+|------------------------------------------------------------------------------
+| File      : dfs_def.h, the definitions of Device FileSystem
+|------------------------------------------------------------------------------
+| Chang Logs:
+| Date           Author       notes
+| 2004-10-01     ffxz         The first version.
+| 2004-10-14     ffxz         Clean up the code.
+| 2005-01-22     ffxz		  Clean up the code, port to MinGW
++------------------------------------------------------------------------------
+*/
+
+#ifndef __DFS_DEF_H__
+#define __DFS_DEF_H__
+
+#include <rtthread.h>
+#include <dfs_config.h>
+
+#if defined(RT_USING_NEWLIB) || defined (RT_USING_MINILIBC)
+#include <string.h>
+#endif
+
+#ifndef __D_FS__
+#define __D_FS__
+#endif
+
+/* Device error codes */
+#define DFS_STATUS_ENOENT		2		/* No such file or directory */
+#define DFS_STATUS_EIO		 	5		/* I/O error */
+#define DFS_STATUS_ENXIO		6		/* No such device or address */
+#define DFS_STATUS_EBADF		9		/* Bad file number */
+#define DFS_STATUS_EAGIAN		11		/* Try again */
+#define DFS_STATUS_ENOMEM		12		/* no memory */
+#define DFS_STATUS_EBUSY		16		/* Device or resource busy */
+#define DFS_STATUS_EEXIST		17		/* File exists */
+#define DFS_STATUS_EXDEV		18		/* Cross-device link */
+#define DFS_STATUS_ENODEV		19		/* No such device */
+#define DFS_STATUS_ENOTDIR		20		/* Not a directory */
+#define DFS_STATUS_EISDIR		21		/* Is a directory */
+#define DFS_STATUS_EINVAL		22		/* Invalid argument */
+#define DFS_STATUS_ENOSPC		28		/* No space left on device */
+#define DFS_STATUS_EROFS		30		/* Read-only file system */
+#define DFS_STATUS_ENOSYS		38		/* Function not implemented */
+#define DFS_STATUS_ENOTEMPTY	39		/* Directory not empty */
+#define DFS_STATUS_EMMOUNT		128		/* Filesystem table full */
+
+/* Operation flags */
+#define DFS_O_RDONLY		0000000
+#define DFS_O_WRONLY		0000001
+#define DFS_O_RDWR			0000002
+#define DFS_O_ACCMODE		0000003
+#define DFS_O_CREAT			0000100
+#define DFS_O_EXCL			0000200
+#define DFS_O_TRUNC			0001000
+#define DFS_O_APPEND		0002000
+#define DFS_O_DIRECTORY		0200000
+
+/* File flags */
+#define DFS_F_OPEN			0x01000000
+#define DFS_F_DIRECTORY		0x02000000
+#define DFS_F_EOF			0x04000000
+#define DFS_F_ERR			0x08000000
+
+/* Seek flags */
+#define DFS_SEEK_SET         0
+#define DFS_SEEK_CUR         1
+#define DFS_SEEK_END         2
+
+/* Stat codes */
+#define DFS_S_IFMT		00170000
+#define DFS_S_IFSOCK	0140000
+#define DFS_S_IFLNK		0120000
+#define DFS_S_IFREG		0100000
+#define DFS_S_IFBLK		0060000
+#define DFS_S_IFDIR  	0040000
+#define DFS_S_IFCHR  	0020000
+#define DFS_S_IFIFO  	0010000
+#define DFS_S_ISUID  	0004000
+#define DFS_S_ISGID  	0002000
+#define DFS_S_ISVTX  	0001000
+
+#define DFS_S_ISLNK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFLNK)
+#define DFS_S_ISREG(m)	(((m) & DFS_S_IFMT) == DFS_S_IFREG)
+#define DFS_S_ISDIR(m)	(((m) & DFS_S_IFMT) == DFS_S_IFDIR)
+#define DFS_S_ISCHR(m)	(((m) & DFS_S_IFMT) == DFS_S_IFCHR)
+#define DFS_S_ISBLK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFBLK)
+#define DFS_S_ISFIFO(m)	(((m) & DFS_S_IFMT) == DFS_S_IFIFO)
+#define DFS_S_ISSOCK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFSOCK)
+
+#define DFS_S_IRWXU 	00700
+#define DFS_S_IRUSR 	00400
+#define DFS_S_IWUSR 	00200
+#define DFS_S_IXUSR 	00100
+
+#define DFS_S_IRWXG 	00070
+#define DFS_S_IRGRP 	00040
+#define DFS_S_IWGRP 	00020
+#define DFS_S_IXGRP 	00010
+
+#define DFS_S_IRWXO 	00007
+#define DFS_S_IROTH 	00004
+#define DFS_S_IWOTH 	00002
+#define DFS_S_IXOTH 	00001
+
+#define DEVICE_GETGEOME 		0
+#define DEVICE_GETINFO			1
+#define DEVICE_FORMAT 			2
+#define DEVICE_CLEAN_SECTOR 	3
+
+struct device_geometry
+{
+	rt_uint32_t sector_count;		/* count of sectors */
+	rt_uint32_t cylinder_count;		/* count of cylinder */
+	rt_uint32_t sectors_per_track;	/* number of sectors per track */
+	rt_uint32_t head_count;			/* count of head */
+	rt_uint32_t bytes_per_sector;	/* number of bytes per sector */
+};
+
+struct dfs_stat
+{
+	rt_device_t st_dev;
+	rt_uint16_t st_mode;
+	rt_uint32_t st_size;
+	rt_time_t  	st_mtime;
+	rt_uint32_t st_blksize;
+};
+#define stat dfs_stat
+
+/* File types */
+#define FT_REGULAR		0
+#define FT_SOCKET		1
+#define FT_DIRECTORY	2
+
+/* file descriptor */
+struct dfs_fd
+{
+    char path[DFS_PATH_MAX + 1];/* Name (below mount point) */
+    int type;					/* Type (regular or socket) */
+    int ref_count;				/* Descriptor reference count */
+
+    struct dfs_filesystem* fs;	/* Resident file system */
+
+    rt_uint32_t flags;			/* Descriptor flags */
+    rt_size_t 	size;			/* Size in bytes */
+    rt_off_t  	pos;			/* Current file position */
+
+    void *data;					/* Specific file system data */
+};
+
+#define DFS_DT_UNKNOWN	0x00
+#define DFS_DT_REG		0x01
+#define DFS_DT_DIR		0x02
+
+struct dfs_dirent
+{
+	rt_uint8_t d_type;				/* The type of the file */
+	rt_uint8_t d_namlen;			/* The length of the not including the terminating null file name */
+	rt_uint16_t d_reclen;				/* length of this record */
+	char   d_name[256];			/* The null-terminated file name */
+};
+#define dirent dfs_dirent
+
+struct dfs_session
+{
+	rt_mailbox_t mbox;
+};
+
+#endif
diff --git a/filesystem/dfs/include/dfs_efs.h b/filesystem/dfs/include/dfs_efs.h
new file mode 100644
index 0000000000..122f33a8ac
--- /dev/null
+++ b/filesystem/dfs/include/dfs_efs.h
@@ -0,0 +1,29 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_efs.h

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2008-08-30     Yi.Qiu

++------------------------------------------------------------------------------

+*/

+

+#ifndef __DFS_EFS_H__

+#define __DFS_EFS_H__

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+int efsl_init(void);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/filesystem/dfs/include/dfs_fat.h b/filesystem/dfs/include/dfs_fat.h
new file mode 100644
index 0000000000..65af6cebb3
--- /dev/null
+++ b/filesystem/dfs/include/dfs_fat.h
@@ -0,0 +1,29 @@
+/*
++------------------------------------------------------------------------------
+| Project   : Device Filesystem
++------------------------------------------------------------------------------
+| Copyright 2004, 2005  www.fayfayspace.org.
+| All rights reserved.
+|------------------------------------------------------------------------------
+| File      : dfs_fat.h, FAT 12/16/32 file system definitions
+|------------------------------------------------------------------------------
+| Chang Logs:
+| Date           Author       Notes
+| 2003-03-30     ffxz
++------------------------------------------------------------------------------
+*/
+
+#ifndef __DFS_FAT_H__
+#define __DFS_FAT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int fatfs_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/filesystem/dfs/include/dfs_fs.h b/filesystem/dfs/include/dfs_fs.h
new file mode 100644
index 0000000000..4299e0d6ba
--- /dev/null
+++ b/filesystem/dfs/include/dfs_fs.h
@@ -0,0 +1,87 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_fs.h, the filesystem related defines of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-02-22     ffxz         The first version.

++------------------------------------------------------------------------------

+*/

+#ifndef __DFS_FS_H__

+#define __DFS_FS_H__

+

+#include <dfs_def.h>

+#include <dfs_config.h>

+

+/* Pre-declaration */

+struct dfs_filesystem;

+struct dfs_fd;

+struct dfs_dirent;

+

+/* File system operations struct */

+struct dfs_filesystem_operation

+{

+	char name[DFS_FS_NAME_MAX + 1];

+

+	int (*mount)	(struct dfs_filesystem* fs);

+	int (*unmount)	(struct dfs_filesystem* fs);

+

+	int (*open)	(struct dfs_fd* fd);

+	int (*close)	(struct dfs_fd* fd);

+	int (*ioctl)	(struct dfs_fd* fd, int cmd, void *args);

+	int (*read)	(struct dfs_fd* fd, void* buf, rt_size_t count);

+	int (*write)	(struct dfs_fd* fd, const void* buf, rt_size_t count);

+	int (*lseek)	(struct dfs_fd* fd, rt_off_t offset);

+	int (*getdents)	(struct dfs_fd* fd, struct dfs_dirent* dirp, rt_uint32_t count);

+

+	int (*unlink)	(struct dfs_filesystem* fs, const char* pathname);

+	int (*stat)		(struct dfs_filesystem* fs, const char* filename, struct dfs_stat* buf);

+	int (*rename)	(struct dfs_filesystem* fs, const char* oldpath, const char* newpath);

+};

+

+/* Mounted file system */

+struct dfs_filesystem

+{

+	rt_device_t dev_id;					/* Attached device */

+

+	char path[DFS_PATH_MAX + 1];			/* File system mount point */

+	struct dfs_filesystem_operation* ops;	/* Operations for file system type */

+	rt_uint32_t block_id;					/* Current block_id on attached device */

+

+	void *data;							/* Specific file system data */

+};

+

+/* file system partition table */

+struct dfs_partition

+{

+	rt_uint8_t type;		/* file system type */

+	rt_off_t  offset;		/* partition start offset */

+	rt_size_t size;			/* partition size */

+	rt_sem_t lock;	

+};

+

+int dfs_register(struct dfs_filesystem_operation* ops);

+struct dfs_filesystem* dfs_filesystem_lookup(const char *path);

+rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex);

+

+int dfs_mount(const char* device_name, const char* path,

+       const char* filesystemtype, rt_uint32_t rwflag, const

+       void* data);

+int dfs_unmount(const char *specialfile);

+

+/* extern variable */

+extern struct dfs_filesystem_operation* filesystem_operation_table[];

+extern struct dfs_filesystem filesystem_table[];

+

+extern rt_sem_t filesystem_table_lock;

+extern rt_sem_t filesystem_operation_table_lock;

+

+extern char working_directory[];

+extern rt_sem_t working_directory_lock;

+

+#endif

diff --git a/filesystem/dfs/include/dfs_init.h b/filesystem/dfs/include/dfs_init.h
new file mode 100644
index 0000000000..712ce61156
--- /dev/null
+++ b/filesystem/dfs/include/dfs_init.h
@@ -0,0 +1,42 @@
+/*

+

++------------------------------------------------------------------------------

+

+| Project   : Device Filesystem

+

++------------------------------------------------------------------------------

+

+| Copyright 2004, 2005  www.fayfayspace.org.

+

+| All rights reserved.

+

+|------------------------------------------------------------------------------

+

+| File      : dfs_init.h, the initilization definitions of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+

+| Date           Author       Notes

+

+| 2005-02-21     ffxz         The first version.

++------------------------------------------------------------------------------

+*/

+

+#ifndef __DFS_INIT_H__

+#define __DFS_INIT_H__

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/* initilization of dfs */

+void dfs_init(void);

+

+/* initilization of dfs with filesystem server */

+void dfs_server_init(void);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/filesystem/dfs/include/dfs_posix.h b/filesystem/dfs/include/dfs_posix.h
new file mode 100644
index 0000000000..a6ddfe1474
--- /dev/null
+++ b/filesystem/dfs/include/dfs_posix.h
@@ -0,0 +1,100 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_posix.h, the filesystem related defines of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2009-05-27     Yi.qiu         The first version.

++------------------------------------------------------------------------------

+*/

+#ifndef __DFS_POSIX_H__

+#define __DFS_POSIX_H__

+

+#include <dfs_raw.h>

+

+#define O_RDONLY	DFS_O_RDONLY

+#define O_WRONLY 	DFS_O_WRONLY

+#define O_RDWR		DFS_O_RDWR

+#define O_ACCMODE	DFS_O_ACCMODE

+#define O_CREAT		DFS_O_CREAT

+#define O_EXCL		DFS_O_EXCL

+#define O_TRUNC		DFS_O_TRUNC

+#define O_APPEND	DFS_O_APPEND

+#define O_DIRECTORY DFS_O_DIRECTORY

+

+#define S_IFMT 		DFS_S_IFMT

+#define S_IFSOCK		DFS_S_IFSOCK

+#define S_IFLNK		DFS_S_IFLNK	

+#define S_IFREG		DFS_S_IFREG	

+#define S_IFBLK		DFS_S_IFBLK	

+#define S_IFDIR		DFS_S_IFDIR 

+#define S_IFCHR		DFS_S_IFCHR 

+#define S_IFIFO		DFS_S_IFIFO 

+#define S_ISUID		DFS_S_ISUID 

+#define S_ISGID		DFS_S_ISGID 

+#define S_ISVTX		DFS_S_ISVTX 

+

+#define S_ISLNK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFLNK)

+#define S_ISREG(m)	(((m) & DFS_S_IFMT) == DFS_S_IFREG)

+#define S_ISDIR(m)	(((m) & DFS_S_IFMT) == DFS_S_IFDIR)

+#define S_ISCHR(m)	(((m) & DFS_S_IFMT) == DFS_S_IFCHR)

+#define S_ISBLK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFBLK)

+#define S_ISFIFO(m)	(((m) & DFS_S_IFMT) == DFS_S_IFIFO)

+#define S_ISSOCK(m)	(((m) & DFS_S_IFMT) == DFS_S_IFSOCK)

+

+#define S_IRWXU		DFS_S_IRWXU

+#define S_IRUSR		DFS_S_IRUSR

+#define S_IWUSR		DFS_S_IWUSR

+#define S_IXUSR		DFS_S_IXUSR

+

+#define S_IRWXG		DFS_S_IRWXG

+#define S_IRGRP		DFS_S_IRGRP

+#define S_IWGRP		DFS_S_IWGRP

+#define S_IXGRP		DFS_S_IXGRP

+

+#define S_IRWXO		DFS_S_IRWXO

+#define S_IROTH		DFS_S_IROTH

+#define S_IWOTH		DFS_S_IWOTH

+#define S_IXOTH		DFS_S_IXOTH

+

+#define SEEK_SET	DFS_SEEK_SET

+#define SEEK_CUR	DFS_SEEK_CUR

+#define SEEK_END	DFS_SEEK_END

+

+typedef struct 

+{

+	int fd;		/* directory file */

+	char buf[512];

+	int num;

+	int cur;

+	rt_sem_t *sem;

+} DIR;

+

+/* file api*/

+int open(const char *file, int flags, int mode);

+int close(int d);

+int read(int fd, char *buf, int len);

+int write(int fd, char *buf, int len);

+int lseek(int fd, int offset, int dir);

+int rename(const char* old, const char* new );

+int unlink(const char *pathname);

+int stat(const char *file, struct dfs_stat *buf);

+

+/* directory api*/

+int mkdir (const char *path, rt_uint16_t mode);

+int rmdir(const char *path);

+DIR* opendir(const char* name);

+struct dfs_dirent* readdir(DIR *d);

+rt_off_t telldir(DIR *d);

+void seekdir(DIR *d, rt_off_t offset);

+void rewinddir(DIR *d);

+int closedir(DIR* d);

+int chdir(const char *path);

+char* getcwd(char *buf, rt_size_t size);

+

+#endif

diff --git a/filesystem/dfs/include/dfs_raw.h b/filesystem/dfs/include/dfs_raw.h
new file mode 100644
index 0000000000..dd6bfb0cad
--- /dev/null
+++ b/filesystem/dfs/include/dfs_raw.h
@@ -0,0 +1,38 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_raw.h, the raw APIs of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-01-26     ffxz		  The first version

++------------------------------------------------------------------------------

+*/

+

+#ifndef __DFS_RAW_H__

+#define __DFS_RAW_H__

+

+#include <dfs_def.h>

+#include <dfs_fs.h>

+

+int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags);

+int dfile_raw_close(struct dfs_fd* fd);

+int dfile_raw_ioctl(struct dfs_fd* fd, int cmd, void *args);

+int dfile_raw_read(struct dfs_fd* fd, void *buf, rt_size_t len);

+int dfile_raw_getdents(struct dfs_fd* fd, struct dfs_dirent* dirp, rt_size_t nbytes);

+int dfile_raw_unlink(const char *path);

+int dfile_raw_write(struct dfs_fd* fd, const void *buf, rt_size_t len);

+int dfile_raw_lseek(struct dfs_fd* fd, rt_off_t offset);

+int dfile_raw_stat(const char *path, struct dfs_stat *buf);

+int dfile_raw_rename(const char* oldpath, const char* newpath);

+

+/* FD APIs */

+int fd_new(void);

+struct dfs_fd* fd_get(int fd);

+void fd_put(struct dfs_fd* fd);

+

+#endif

diff --git a/filesystem/dfs/include/dfs_util.h b/filesystem/dfs/include/dfs_util.h
new file mode 100644
index 0000000000..948abe09cc
--- /dev/null
+++ b/filesystem/dfs/include/dfs_util.h
@@ -0,0 +1,35 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_util.h, some misc definitions of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-01-26     ffxz         The first version

++------------------------------------------------------------------------------

+*/

+

+#ifndef __DFS_UTIL_H__

+#define __DFS_UTIL_H__

+

+#include <dfs_def.h>

+

+int dir_name(const char* path, char* dirname, int len);

+int file_name(const char* path, char* filename, int len);

+

+int next_dir_name(const char* path, int pos, char* next);

+void build_fullpath(const char *directory, const char *filename, char *fullpath);

+int str_is_prefix(const char* prefix, const char* str);

+

+#if !defined(RT_USING_MINILIBC) && !defined(RT_USING_NEWLIB)

+char *strrchr(const char *t, int c);

+#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION / 10000 < 35)

+int strncasecmp(const char* s1, const char* s2, rt_size_t len);

+#endif /* end of __ARMCC_VERSION */

+#endif

+

+#endif

diff --git a/filesystem/dfs/src/dfs_cache.c b/filesystem/dfs/src/dfs_cache.c
new file mode 100644
index 0000000000..cd4deab415
--- /dev/null
+++ b/filesystem/dfs/src/dfs_cache.c
@@ -0,0 +1,273 @@
+/*
++------------------------------------------------------------------------------
+| Project   : Device Filesystem
++------------------------------------------------------------------------------
+| Copyright 2004 - 2009  www.rt-thread.org
+| All rights reserved.
+|------------------------------------------------------------------------------
+| File      : dfs_cache.c, the LUT disk cache implementation
+|------------------------------------------------------------------------------
+| Chang Logs:
+| Date           Author       Notes
+| 2009-04-26     bernard      The first version.
++------------------------------------------------------------------------------
+*/
+#include "dfs_cache.h"
+
+#define ioman_isReqRo(mode)  ((mode)&(IOM_MODE_READONLY))
+#define ioman_isReqRw(mode)  ((mode)&(IOM_MODE_READWRITE))
+#define ioman_isReqExp(mode) ((mode)&(IOM_MODE_EXP_REQ))
+
+rt_err_t ioman_init(IOManager* ioman)
+{
+    register rt_uint32_t index;
+    RT_ASSERT(ioman != RT_NULL);
+
+	ioman->numbuf = DFS_CACHE_MAX_NUM;

+	

+	rt_memset(ioman->sector, 0,sizeof(ioman->sector));

+	rt_memset(ioman->status, 0,sizeof(ioman->status));

+	rt_memset(ioman->usage, 0, sizeof(ioman->usage));

+	rt_memset(ioman->ring_fifo, 0, sizeof(ioman->ring_fifo));

+	rt_memset(ioman->cache, 0, sizeof(ioman->cache));

+	
+    /* init fifo */
+    for (index = 0; index < ioman->numbuf; index ++)
+    {
+    	ioman->ring_fifo[index] = ioman->numbuf - index - 1;
+    }
+
+    return RT_EOK;
+}
+
+/*
+ * get the last fifo item and put it to the top of fifo ring
+ */
+static rt_uint8_t ioman_ring_fifo_swap(IOManager *ioman)
+{
+    rt_uint8_t bp;
+    rt_uint32_t index;
+
+    bp = ioman->ring_fifo[ioman->numbuf - 1];
+    for (index = ioman->numbuf - 1; index > 0; index --)
+    {
+        ioman->ring_fifo[index] = ioman->ring_fifo[index - 1];
+    }
+
+    ioman->ring_fifo[0] = bp;
+
+    return bp;
+}
+
+/*
+ * get the index of bp in fifo ring and then put it to the top of
+ * fifo ring
+ */
+static void ioman_ring_fifo_relocate(IOManager *ioman, rt_uint32_t bp)
+{
+    rt_uint32_t bp_index = 0;
+    register rt_uint32_t index;
+
+    /* find bp in fifo ring */
+    for (index = 0; index < ioman->numbuf; index ++)
+    {
+        if (ioman->ring_fifo[index] == bp)
+        {
+            bp_index = index;
+            break;
+        }
+    }
+
+    /* not found bp in fifo ring */
+    if (index == ioman->numbuf) return;
+
+    /* move the bp to the top of fifo ring */
+    for (index = bp_index; index > 0; index --)
+    {
+        ioman->ring_fifo[index] = ioman->ring_fifo[index - 1];
+    }
+    ioman->ring_fifo[0] = bp;
+}
+
+/*
+ * get last bp in fifo ring
+ */
+rt_inline rt_uint8_t ioman_ring_fifo_last(IOManager *ioman)
+{
+    RT_ASSERT(ioman != RT_NULL);
+    return ioman->ring_fifo[ioman->numbuf - 1];
+}
+
+static rt_err_t ioman_readSector(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf)
+{
+    rt_err_t result;
+
+    RT_ASSERT(buf != RT_NULL);
+
+    result = rt_device_read(ioman->device, address * DFS_SECTOR_SIZE, buf, DFS_SECTOR_SIZE);
+    if (result == DFS_SECTOR_SIZE) return RT_EOK;
+
+	return -RT_ERROR;
+}
+
+static rt_err_t ioman_writeSector(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf)
+{
+    rt_err_t result;
+
+    RT_ASSERT(buf != RT_NULL);
+
+    result = rt_device_write(ioman->device, address * DFS_SECTOR_SIZE, buf, DFS_SECTOR_SIZE);
+    if (result == DFS_SECTOR_SIZE) return RT_EOK;
+
+	return -RT_ERROR;
+}
+
+static rt_int32_t ioman_findSectorInCache(IOManager *ioman, rt_uint32_t address)
+{
+	rt_uint32_t c;
+
+	for(c=0;c<ioman->numbuf;c++)
+	{
+		if((ioman->status[c] & (1 << IOMAN_STATUS_ATTR_VALIDDATA)) &&
+            ioman->sector[c] == address)
+            return (c);
+	}
+
+	return -RT_ERROR;
+}

+
+static rt_err_t ioman_flushSector(IOManager *ioman, rt_uint32_t bp)
+{
+    rt_err_t result;
+
+    RT_ASSERT(ioman != RT_NULL);
+
+    result = ioman_writeSector(ioman, ioman->sector[bp], &ioman->cache[bp][0]);
+    if (result == RT_EOK)
+    {
+        /* set status */
+        ioman->status[bp] &= ~(1 << IOMAN_STATUS_ATTR_WRITE);
+    }
+
+    return result;
+}
+
+rt_uint8_t* ioman_getSector(IOManager *ioman, rt_uint32_t address, rt_uint8_t mode)
+{
+    rt_int32_t bp;
+
+    RT_ASSERT(ioman != RT_NULL);
+
+    bp = ioman_findSectorInCache(ioman, address);
+    if (bp != -RT_ERROR)
+    {
+        /* incress cache usage */
+        ioman->usage[bp] ++;
+
+        /* relocate bp in fifo ring */
+        ioman_ring_fifo_relocate(ioman, bp);
+
+        if (ioman_isReqRw(mode))
+            ioman->status[bp] |= (1 << IOMAN_STATUS_ATTR_WRITE);
+
+        return &(ioman->cache[bp][0]);
+    }
+
+    /* not find in cache, get the last bp in fifo ring */
+    bp = ioman_ring_fifo_last(ioman);
+    if ((ioman->status[bp] & (1 << IOMAN_STATUS_ATTR_WRITE)) &&

+		ioman->usage[bp] == 0)
+    {
+        /* it's a writable buffer, flush it */
+        ioman_flushSector(ioman, bp);
+    }
+
+    /* strip last bp in fifo ring */
+    bp = ioman_ring_fifo_swap(ioman);
+
+    /* read sector */
+    ioman_readSector(ioman, address, &ioman->cache[bp][0]);
+    ioman->sector[bp] = address;
+    ioman->usage [bp] = 1;
+    ioman->status[bp] = (1 << IOMAN_STATUS_ATTR_VALIDDATA);

+    if (ioman_isReqRw(mode))
+		ioman->status[bp] |= (1 << IOMAN_STATUS_ATTR_WRITE);

+
+	return &ioman->cache[bp][0];
+}
+
+rt_err_t ioman_releaseSector(IOManager *ioman, rt_uint8_t* buf)
+{
+	rt_uint32_t bp;
+
+    /* get buffer place */
+    bp = ((rt_uint32_t)buf - (rt_uint32_t)&ioman->cache[0]) / DFS_SECTOR_SIZE;
+
+    /* decrease usage */
+    if (ioman->usage[bp] >  0) ioman->usage[bp] --;
+	if (ioman->usage[bp] == 0)
+	{
+		if(ioman->status[bp] & (1 << IOMAN_STATUS_ATTR_WRITE))
+		{
+			ioman_flushSector(ioman,bp);
+		}
+	}
+
+	return RT_EOK;
+}
+
+rt_err_t ioman_flushRange(IOManager *ioman, rt_uint32_t address_low, rt_uint32_t address_high)
+{
+	rt_uint32_t c;
+
+	if(address_low > address_high)
+	{
+		c = address_low; address_low = address_high; address_high = c;
+	}
+
+	for(c = 0; c < ioman->numbuf; c++)
+	{
+		if((ioman->sector[c]>=address_low)
+            && (ioman->sector[c]<=address_high)
+            && (ioman->status[c] & (1 << IOMAN_STATUS_ATTR_WRITE)))
+		{
+			if(ioman_flushSector(ioman,c) != RT_EOK)
+				return -RT_ERROR;
+
+            /* remove writable status */
+			if(ioman->usage[c]==0) ioman->status[c] &= ~IOMAN_STATUS_ATTR_WRITE;
+		}
+	}
+
+	return RT_EOK;
+}

+
+/*

+ * read multi-sectors directly (none-cachable)

+ */
+rt_err_t ioman_directSectorRead(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf, rt_uint32_t numsector)
+{
+    rt_err_t result;
+
+    RT_ASSERT(buf != RT_NULL);
+
+    result = rt_device_read(ioman->device, address * DFS_SECTOR_SIZE, buf, DFS_SECTOR_SIZE * numsector);
+    if (result == DFS_SECTOR_SIZE * numsector) return RT_EOK;
+
+	return -RT_ERROR;
+}

+
+/*

+ * write multi-sectors directly (none-cachable)

+ */
+rt_err_t ioman_directSectorWrite(IOManager *ioman, rt_uint32_t address, rt_uint8_t* buf, rt_uint32_t numsector)
+{
+    rt_err_t result;
+
+    RT_ASSERT(buf != RT_NULL);
+
+    result = rt_device_write(ioman->device, address * DFS_SECTOR_SIZE, buf, DFS_SECTOR_SIZE * numsector);
+    if (result == DFS_SECTOR_SIZE * numsector) return RT_EOK;
+
+	return -RT_ERROR;
+}
diff --git a/filesystem/dfs/src/dfs_fs.c b/filesystem/dfs/src/dfs_fs.c
new file mode 100644
index 0000000000..f0ca291c24
--- /dev/null
+++ b/filesystem/dfs/src/dfs_fs.c
@@ -0,0 +1,362 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_fs.c, the filesystem related implementations of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-02-22     ffxz         The first version.                     

++------------------------------------------------------------------------------

+*/

+#include <dfs_fs.h>

+#include <dfs_raw.h>

+#include <dfs_util.h>

+

+#include <string.h>

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfs_register

++------------------------------------------------------------------------------

+| Description : registers a filesystem

+|

+| Parameters  : ops, the implementation of filesystem

+| Returns     : the status of register

+|               0 , successful

+|               -1, failed

++------------------------------------------------------------------------------

+*/

+int dfs_register(struct dfs_filesystem_operation* ops)

+{

+	int index;

+

+	rt_sem_take(filesystem_operation_table_lock, RT_WAITING_FOREVER);

+

+	/* check if this filesystem was already registered */

+	for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++)

+	{

+		if (filesystem_operation_table[index] != RT_NULL &&

+			strcmp(filesystem_operation_table[index]->name, ops->name) == 0)

+			goto err;

+	}

+

+	/* find out an empty filesystem type entry */

+	for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX && filesystem_operation_table[index] != RT_NULL;

+		index++) ;

+	

+	/* filesystem type table full */

+	if (index == DFS_FILESYSTEM_TYPES_MAX) goto err;

+

+	/* save the filesystem's operations */

+	filesystem_operation_table[index] = ops;

+

+	rt_sem_release(filesystem_operation_table_lock);

+	return 0;

+

+err:

+	rt_sem_release(filesystem_operation_table_lock);

+	return -1;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfs_filesystem_lookup

++------------------------------------------------------------------------------

+| Description : lookup the mounted filesystem on the specified path

+|

+| Parameters  : path, the specified path string

+| Returns     : the found filesystem

++------------------------------------------------------------------------------

+*/

+struct dfs_filesystem* dfs_filesystem_lookup(const char *path)

+{

+	struct dfs_filesystem* fs;

+	rt_uint32_t index, fspath, prefixlen;

+

+	fs = RT_NULL;

+	prefixlen = 0;

+

+	/* lock filesystem table */

+	rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER);

+

+	/* lookup it in the filesystem table */

+	for (index = 0; index < DFS_FILESYSTEMS_MAX + 1; index++)

+	{

+		fspath = strlen(filesystem_table[index].path);

+		if (fspath < prefixlen) continue;

+		

+		if ((filesystem_table[index].ops != RT_NULL) &&

+			str_is_prefix(filesystem_table[index].path, path) == 0)

+		{

+			fs = &filesystem_table[index];

+			prefixlen = fspath;

+		}

+	}

+

+	rt_sem_release(filesystem_table_lock);

+	return fs;

+}

+

+rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex)

+{

+#define DPT_ADDRESS		0x1be		/* device partition offset in Boot Sector */

+#define DPT_ITEM_SIZE	16			/* partition item size */

+

+	rt_uint8_t* dpt;

+	rt_uint8_t type;

+	rt_err_t result;

+	

+	RT_ASSERT(part != RT_NULL);

+	RT_ASSERT(buf != RT_NULL);

+	

+	result = RT_EOK;

+	

+	dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE;

+

+	if ((*dpt != 0x80) && (*dpt != 0x00))

+	{

+		/* which is not a partition table */

+		result = -RT_ERROR;

+		return result;

+	}

+	

+	/* get partition type */

+	type = *(dpt+4);

+

+	if (type != 0)

+	{

+		/* set partition type */

+		part->type = type;

+		

+		/* get partition offset and size */

+		part->offset = *(dpt+ 8) | *(dpt+ 9) << 8 | 

+			*(dpt+10) << 16 | *(dpt+11) << 24;

+		part->size = *(dpt+12) | *(dpt+13) << 8 | 

+			*(dpt+14) << 16 | *(dpt+15) << 24;

+

+#ifdef RT_USING_FINSH

+		rt_kprintf("part[%d], begin: %d, size: %d\n", 

+			pindex, part->offset * 512, part->size* 512);

+#endif

+	}

+	else

+	{

+		result = -RT_ERROR;

+	}

+

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfs_mount

++------------------------------------------------------------------------------

+| Description : mount a filesystem to specified path

+|

+| Parameters  : device_name, the implementation of filesystem

+|               path, 

+|               filesystemtype,

+|               rwflag,

+|               data,

+| Returns     : the status of register

+|               0 , successful

+|               -1, failed

++------------------------------------------------------------------------------

+*/

+int dfs_mount(const char* device_name, const char* path,

+       const char* filesystemtype, unsigned long rwflag, const

+       void* data)

+{

+	struct dfs_filesystem_operation* ops;

+	struct dfs_filesystem* fs;

+	char *fullpath=RT_NULL;

+#ifdef RT_USING_WORKDIR	

+	char full_path[DFS_PATH_MAX + 1];

+#endif

+	rt_device_t dev_id;

+	int index;

+

+	/* open specific device */

+	dev_id = rt_device_find(device_name);

+	if (dev_id == RT_NULL)

+	{

+		/* no this device */

+		rt_set_errno(-DFS_STATUS_ENODEV);

+		return -1;

+	}

+

+	/* find out specific filesystem */

+	rt_sem_take(filesystem_operation_table_lock, RT_WAITING_FOREVER);

+	for ( index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++ )

+	{

+		if (strcmp(filesystem_operation_table[index]->name, filesystemtype) == 0)break;

+	}

+

+	/* can't find filesystem */

+	if ( index == DFS_FILESYSTEM_TYPES_MAX )

+	{

+		rt_set_errno(-DFS_STATUS_ENODEV);

+		rt_sem_release(filesystem_operation_table_lock);

+		return -1;

+	}

+	ops = filesystem_operation_table[index];

+	rt_sem_release(filesystem_operation_table_lock);

+

+	/* make full path for special file */

+	fullpath = (char*)path;

+	if ( fullpath[0] != '/') /* not an abstract path */

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		fullpath = full_path;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, path, fullpath);

+		rt_sem_release(working_directory_lock);

+#else

+		rt_set_errno(-DFS_STATUS_ENOTDIR);

+		return -1;

+#endif

+	}

+

+	/* Check if the path exists or not, raw APIs call, fixme */

+	if ( (strcmp(fullpath, "/") != 0) && (strcmp(fullpath, "/dev") != 0) )

+	{

+		struct dfs_fd fd;

+

+		if ( dfile_raw_open(&fd, fullpath, DFS_O_RDONLY | DFS_O_DIRECTORY) < 0 )

+		{

+			rt_set_errno(-DFS_STATUS_ENOTDIR);

+			return -1;

+		}

+		dfile_raw_close(&fd);

+	}

+

+	/* check whether the file system mounted or not */

+	rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER);

+	for (index =0; index < DFS_FILESYSTEMS_MAX; index++)

+	{

+		if ( filesystem_table[index].ops != RT_NULL &&

+			strcmp(filesystem_table[index].path, path) == 0 )

+		{

+			rt_set_errno(-DFS_STATUS_EINVAL);

+			goto err1;

+		}

+	}

+

+	/* find out en empty filesystem table entry */

+	for (index = 0; index < DFS_FILESYSTEMS_MAX && filesystem_table[index].ops != RT_NULL;

+		index++) ;

+	if ( index == DFS_FILESYSTEMS_MAX )	/* can't find en empty filesystem table entry */

+	{

+		rt_set_errno(-DFS_STATUS_EMMOUNT);

+		goto err1;

+	}

+

+	/* register file system */

+	fs = &(filesystem_table[index]);

+	strncpy(fs->path, fullpath, strlen(fullpath));

+	fs->ops = ops;

+	fs->dev_id = dev_id;

+	/* release filesystem_table lock */

+	rt_sem_release(filesystem_table_lock);

+

+	/* open device, but do not check the status of device */

+	rt_device_open(fs->dev_id, RT_DEVICE_OFLAG_RDWR);

+

+	if ( ops->mount == RT_NULL ) /* there is no mount implementation */

+	{

+		rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER);

+

+		/* clear filesystem table entry */

+		rt_memset(fs, 0, sizeof(struct dfs_filesystem));

+

+		rt_sem_release(filesystem_table_lock);

+

+		rt_set_errno(-DFS_STATUS_ENOSYS);

+		return -1;

+	}

+	/* call mount of this filesystem */

+	else if ( ops->mount(fs) < 0 )

+	{

+		/* mount failed */

+		rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER);

+

+		/* close device */

+		rt_device_close(fs->dev_id);

+		

+		/* clear filesystem table entry */

+		rt_memset(fs, 0, sizeof(struct dfs_filesystem));

+

+		rt_sem_release(filesystem_table_lock);

+		return -1;

+	}

+

+	return 0;

+

+err1:

+	rt_sem_release(filesystem_table_lock);

+	return -1;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfs_unmount

++------------------------------------------------------------------------------

+| Description : unmount a filesystem

+|

+| Parameters  : 

+| Returns     : the status of register

+|               0 , successful

+|               -1, failed

++------------------------------------------------------------------------------

+*/

+int dfs_unmount(const char *specialfile)

+{

+	char *fullpath;

+#ifdef RT_USING_WORKDIR	

+	char full_path[DFS_PATH_MAX + 1];

+#endif

+	struct dfs_filesystem* fs = RT_NULL;

+

+	fullpath = (char*)specialfile;

+	if ( fullpath[0] != '/')

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		fullpath = full_path;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, specialfile, fullpath);

+		rt_sem_release(working_directory_lock);

+#else

+		rt_set_errno(-DFS_STATUS_ENOTDIR);

+		return -1;

+#endif

+	}

+

+	/* lock filesystem table */

+	rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER);

+

+	fs = dfs_filesystem_lookup(fullpath);

+	if (fs != RT_NULL && fs->ops->unmount != RT_NULL && fs->ops->unmount(fs) < 0)

+	{

+		goto err1;

+	}

+

+	/* close device, but do not check the status of device */

+	rt_device_close(fs->dev_id);

+

+	/* clear this filesystem table entry */

+	rt_memset(fs, 0, sizeof(struct dfs_filesystem));

+

+	rt_sem_release(filesystem_table_lock);

+

+	return 0;

+

+err1:

+	rt_sem_release(filesystem_table_lock);

+	return -1;

+}

diff --git a/filesystem/dfs/src/dfs_init.c b/filesystem/dfs/src/dfs_init.c
new file mode 100644
index 0000000000..5b72da71ed
--- /dev/null
+++ b/filesystem/dfs/src/dfs_init.c
@@ -0,0 +1,92 @@
+/*
++------------------------------------------------------------------------------
+| Project   : Device Filesystem
++------------------------------------------------------------------------------
+| Copyright 2004, 2005  www.fayfayspace.org.
+| All rights reserved.
+|------------------------------------------------------------------------------
+| File      : dfs.c, the implementation of Device FileSystem
+|------------------------------------------------------------------------------
+| Chang Logs:
+| Date           Author       Notes
+| 2002-12-31     ffxz         The first version.                     
+| 2005-01-22     ffxz         Clean up the code.                     
++------------------------------------------------------------------------------
+*/
+#include <dfs_def.h>
+#include <dfs_config.h>
+
+#include <dfs_fs.h>
+#include <dfs_raw.h>
+
+#include <string.h>
+
+/* Global variables */
+struct dfs_filesystem_operation* filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX + 1];
+struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX + 1];
+
+rt_sem_t filesystem_table_lock;
+rt_sem_t filesystem_operation_table_lock;
+
+#ifdef RT_USING_WORKDIR	
+char working_directory[DFS_PATH_MAX + 1];
+rt_sem_t working_directory_lock;
+#endif
+
+struct dfs_fd fd_table[DFS_FD_MAX + 1];
+rt_sem_t  fd_table_lock;
+
+/*
++------------------------------------------------------------------------------
+| Function    : dfs_init
++------------------------------------------------------------------------------
+| Description : Inits the Device Filesystem
+| Parameters  : null
+| Returns     : null
++------------------------------------------------------------------------------
+*/
+void dfs_init()
+{
+	int index;
+
+	/* clear filesystem operations table */
+	for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX + 1; index++) 
+		filesystem_operation_table[index] = RT_NULL;
+
+	/* create filesystem operations table lock */
+	filesystem_operation_table_lock = rt_sem_create("sem_fot", 1, RT_IPC_FLAG_FIFO); 
+
+	/* clear filesystem table */
+	for (index = 0; index < DFS_FILESYSTEMS_MAX + 1; index++)
+	{
+		rt_memset(filesystem_table[index].path, 0, DFS_PATH_MAX + 1);
+
+		filesystem_table[index].ops = RT_NULL;
+		filesystem_table[index].dev_id = 0;
+		filesystem_table[index].block_id = 0;
+		filesystem_table[index].data = RT_NULL;
+	}
+
+	/* create filesystem table lock */
+	filesystem_table_lock = rt_sem_create("sem_fst", 1, RT_IPC_FLAG_FIFO); 
+
+#ifdef RT_USING_WORKDIR	
+	/* set current working directory */
+	strcpy(working_directory, "/");
+	working_directory_lock = rt_sem_create("sem_wd", 1, RT_IPC_FLAG_FIFO); 
+#endif
+
+	/* clean fd table */
+	for ( index = 0; index < DFS_FD_MAX; index ++)
+	{
+		rt_memset(&fd_table[index], 0, sizeof(struct dfs_fd));
+	}
+
+	/* create fd table lock */
+	fd_table_lock = rt_sem_create("sem_fdt", 1, RT_IPC_FLAG_FIFO); 
+
+#if defined(RT_USING_FINSH) && !defined(FINSH_USING_SYMTAB)
+	dfs_export_finsh();
+#endif
+}
+
diff --git a/filesystem/dfs/src/dfs_posix.c b/filesystem/dfs/src/dfs_posix.c
new file mode 100644
index 0000000000..6ea66a0e76
--- /dev/null
+++ b/filesystem/dfs/src/dfs_posix.c
@@ -0,0 +1,564 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_posix.c, the interface related implementations of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2009-05-27     Yi.qiu       The first version.                     

++------------------------------------------------------------------------------

+*/

+#include <dfs_posix.h>

+

+/*

++------------------------------------------------------------------------------

+| Function    : open

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int open(const char *file, int flags, int mode)

+{

+	int fd, result;

+	struct dfs_fd* d;

+

+	/* allocate a fd */

+	fd = fd_new();

+	if (fd < 0) return -1;

+	d  = fd_get(fd);

+

+	result = dfile_raw_open(d, file, flags);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		fd_put(d);

+		fd_put(d);

+

+		return -1;

+	}

+

+	/* release the ref-count of fd */

+	fd_put(d);

+	return fd;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : close

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int close(int d)

+{

+	int result;

+	struct dfs_fd* fd;

+

+	fd = fd_get(d);

+

+	result = dfile_raw_close(fd);

+	fd_put(fd);

+	fd_put(fd);

+	

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : read

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int read(int fd, char *buf, int   len)

+{

+	int result;

+	struct dfs_fd* d;

+	

+	/* get the fd */

+	d  = fd_get(fd);

+

+	result = dfile_raw_read(d, buf, len);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		fd_put(d);

+		

+		return -1;

+	}

+

+	/* release the ref-count of fd */

+	fd_put(d);

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : write

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int write(int fd, char *buf, int   len)

+{

+	int result;

+	struct dfs_fd* d;

+

+	/* get the fd */

+	d  = fd_get(fd);

+

+	result = dfile_raw_write(d, buf, len);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		fd_put(d);

+		

+		return -1;

+	}

+

+	/* release the ref-count of fd */

+	fd_put(d);

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : lseek

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int lseek(int fd, int   offset, int   dir)

+{

+	int result;

+	struct dfs_fd* d;

+

+	d  = fd_get(fd);

+

+	switch (dir)

+	{

+	case DFS_SEEK_SET:

+		break;

+

+	case DFS_SEEK_CUR:

+		offset += d->pos;

+		break;

+

+	case DFS_SEEK_END:

+		offset = d->pos - offset;

+		break;

+	}

+

+	result = dfile_raw_lseek(d, offset);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		fd_put(d);

+		return -1;

+	}

+

+	/* release the ref-count of fd */

+	fd_put(d);

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : rename

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int rename(const char* old, const char* new )

+{

+	int result;

+

+	result = dfile_raw_rename(old, new);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : unlink

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int unlink(const char *pathname)

+{

+	int result;

+

+	result = dfile_raw_unlink(pathname);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : stat

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int stat(const char *file, struct dfs_stat *buf)

+{

+	int result;

+

+	result = dfile_raw_stat(file, (struct dfs_stat *)buf);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : mkdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int mkdir (const char *path, rt_uint16_t mode)

+{

+	int fd;

+	struct dfs_fd* d;

+	int result;

+

+	fd = fd_new();

+	d = fd_get(fd);

+	

+	result = dfile_raw_open(d, path, DFS_O_DIRECTORY | DFS_O_CREAT);

+	fd_put(d);

+	fd_put(d);

+

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : rmdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int rmdir(const char *pathname)

+{

+	int result;

+

+	result = dfile_raw_unlink(pathname);

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : opendir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+DIR* opendir(const char* name)

+{

+	struct dfs_fd* d;

+	int fd, result;

+	DIR* t;

+

+	t = RT_NULL;

+

+	/* allocate a fd */

+	fd = fd_new();

+	d  = fd_get(fd);

+

+	result = dfile_raw_open(d, name, DFS_O_RDONLY | DFS_O_DIRECTORY);

+	if (result >= 0)

+	{

+		/* open successfully */

+		t = (DIR *) rt_malloc (sizeof(DIR));

+		if (t == RT_NULL)

+		{

+			dfile_raw_close(d);

+			fd_put(d);

+		}

+		else t->fd = fd;

+		fd_put(d);

+		return t;

+	}

+

+	/* open failed */

+	fd_put(d);

+	fd_put(d);

+	rt_set_errno(result);

+

+	return RT_NULL;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : readdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+struct dfs_dirent* readdir(DIR *d)

+{

+	int result;

+	struct dfs_fd* fd;

+	

+	fd = fd_get(d->fd);

+

+	if (!d->num || (d->cur += ((struct dfs_dirent*)(d->buf + d->cur))->d_reclen) >= d->num)

+	{

+		result = dfile_raw_getdents(fd, (struct dfs_dirent*)d->buf, sizeof(d->buf) - 1);

+		if (result <= 0)

+		{

+			rt_set_errno(result);

+			fd_put(fd);

+

+			return RT_NULL;

+		}

+

+		d->num = result;

+		d->cur = 0;

+	}

+

+	fd_put(fd);

+	return (struct dfs_dirent*)(d->buf+d->cur);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : telldir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+rt_off_t telldir(DIR *d)

+{

+	struct dfs_fd* fd;

+	rt_off_t result;

+

+	fd = fd_get(d->fd);

+	result = fd->pos - d->num + d->cur;

+	fd_put(fd);

+

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : seekdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+void seekdir(DIR *d, rt_off_t offset)

+{

+	struct dfs_fd* fd;

+	

+	fd = fd_get(d->fd);

+	if (dfile_raw_lseek(fd, offset) >= 0) d->num = d->cur = 0;

+	fd_put(fd);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : rewinddir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+void rewinddir(DIR *d)

+{

+	struct dfs_fd* fd;

+	

+	fd = fd_get(d->fd);

+	if (dfile_raw_lseek(fd, 0) >= 0) d->num = d->cur = 0;

+	fd_put(fd);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : closedir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int closedir(DIR* d)

+{

+	int result;

+	struct dfs_fd* fd;

+

+	fd = fd_get(d->fd);

+

+	result = dfile_raw_close(fd);

+	fd_put(fd);

+

+	rt_free(d);

+

+	if (result < 0)

+	{

+		rt_set_errno(result);

+		return -1;

+	}

+	else return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : chdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int chdir(const char *path)

+{

+	char* fullpath, full_path[DFS_PATH_MAX + 1];

+	

+	if(path == RT_NULL || strlen(path) > DFS_PATH_MAX)

+		return -1;

+

+	fullpath = (char*)path;

+	if ( fullpath[0] != '/' )

+	{

+		/* build full path */

+		fullpath = full_path;

+#ifdef RT_USING_WORKDIR	

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, path, fullpath);

+		strcpy(working_directory, fullpath);

+		rt_sem_release(working_directory_lock);

+#endif		

+	}

+	else

+	{

+#ifdef RT_USING_WORKDIR	

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		rt_strncpy(working_directory, path, strlen(path) + 1);

+		working_directory[strlen(path)] = '\0';

+		rt_sem_release(working_directory_lock);

+#endif		

+	}

+	

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : chdir

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+char* getcwd(char *buf, rt_size_t size)

+{

+#ifdef RT_USING_WORKDIR	

+	rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+	rt_strncpy(buf, working_directory, size);

+	rt_sem_release(working_directory_lock);

+#endif

+	return buf;

+}

+

diff --git a/filesystem/dfs/src/dfs_raw.c b/filesystem/dfs/src/dfs_raw.c
new file mode 100644
index 0000000000..816197c5e9
--- /dev/null
+++ b/filesystem/dfs/src/dfs_raw.c
@@ -0,0 +1,668 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_raw.c, the raw APIs of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-02-22     ffxz         The first version.                     

++------------------------------------------------------------------------------

+*/

+#include <dfs_raw.h>

+#include <dfs_util.h>

+#include <string.h>

+

+extern struct dfs_fd fd_table[DFS_FD_MAX + 1];

+extern rt_sem_t  fd_table_lock;

+

+/*

++------------------------------------------------------------------------------

+| Function    : fd_new

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int fd_new(void)

+{

+	struct dfs_fd* d;

+	int idx;

+

+	rt_sem_take(fd_table_lock, RT_WAITING_FOREVER);

+

+	/* find an empty fd entry */

+	for (idx = 3; idx < DFS_FD_MAX && fd_table[idx].ref_count > 0; idx++);

+

+	/* can't find an empty fd entry */

+	if (idx == DFS_FD_MAX)

+	{

+		rt_sem_release(fd_table_lock);

+		return -1;

+	}

+

+	d = &(fd_table[idx]);

+	d->ref_count = 1;

+	rt_sem_release(fd_table_lock);

+

+	return idx;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : fd_get

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+struct dfs_fd* fd_get(int fd)

+{

+	struct dfs_fd* d;

+

+	if ( fd < 3 || fd > DFS_FD_MAX ) return RT_NULL;

+

+	d = &fd_table[fd];

+

+	rt_sem_take(fd_table_lock, RT_WAITING_FOREVER);

+	d->ref_count ++;

+	rt_sem_release(fd_table_lock);

+

+	return d;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : fd_put

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+void fd_put(struct dfs_fd* fd)

+{

+	rt_sem_take(fd_table_lock, RT_WAITING_FOREVER);

+	fd->ref_count --;

+	/* clear this fd entry */

+	if ( fd->ref_count == 0 )

+	{

+		rt_memset(fd, 0, sizeof(struct dfs_fd));

+	}

+	rt_sem_release(fd_table_lock);

+};

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_open

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags)

+{

+	struct dfs_filesystem* fs;

+	char *fullpath;

+#ifdef RT_USING_WORKDIR	

+	char full_path[DFS_PATH_MAX + 1];

+#endif

+	int fspathlen, result;

+

+	/* parameter check */

+	if ( fd == RT_NULL ) return -DFS_STATUS_EINVAL;

+

+	/* make sure we have an absolute path */

+	fullpath = (char*)path;

+	if ( fullpath[0] != '/')

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		fullpath = &full_path[0];

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, path, fullpath);

+		rt_sem_release(working_directory_lock);

+#else

+#ifdef RT_USING_FINSH

+		rt_kprintf("bad filename");

+#endif

+		return -1;

+#endif

+	}

+

+	dfs_log(DFS_DEBUG_INFO, ("open file:%s", fullpath));

+

+	/* find filesystem */

+	fs = dfs_filesystem_lookup(fullpath);

+	if ( fs == RT_NULL ) return -DFS_STATUS_ENOENT;

+

+	dfs_log(DFS_DEBUG_INFO, ("open in filesystem:%s", fs->ops->name));

+	fd->fs = fs;

+

+	/* initilize the fd item */

+	fd->type = FT_REGULAR;

+	//fd->ref_count = 1;

+	fd->flags = flags;

+	fd->size = 0;

+	fd->pos = 0;

+

+	fspathlen = strlen(fs->path);

+	rt_memset(fd->path, 0, DFS_PATH_MAX + 1);

+	if (*(fullpath + fspathlen) != '/') strcpy(fd->path, "/");

+	strcat(fd->path, fullpath + fspathlen);

+

+	/* specific file system open routine */

+	if (fs->ops->open == RT_NULL)

+	{

+		/* clear fd */

+		rt_memset(fd->path, 0, DFS_PATH_MAX + 1);

+

+		fd->type = FT_REGULAR;

+		fd->ref_count = 0;

+		fd->fs = RT_NULL;

+		fd->flags = 0;

+		fd->size = 0;

+		fd->pos = 0;

+		fd->data = RT_NULL;

+

+		return -DFS_STATUS_ENOSYS;

+	}

+

+	if ((result = fs->ops->open(fd)) < 0)

+	{

+		/* clear fd */

+		fd->fs = RT_NULL;

+		fd->flags = 0;

+		fd->data = RT_NULL;

+

+		dfs_log(DFS_DEBUG_INFO, ("open failed"));

+

+		return result;

+	}

+

+	fd->flags |= DFS_F_OPEN;

+	if ( flags & DFS_O_DIRECTORY ) fd->flags |= DFS_F_DIRECTORY;

+

+	dfs_log(DFS_DEBUG_INFO, ("open successful"));

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_close

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_close(struct dfs_fd* fd)

+{

+	int result = 0;

+

+	if (fd != RT_NULL && fd->fs->ops->close != RT_NULL) result = fd->fs->ops->close(fd);

+

+	/* close fd error, return */

+	if ( result < 0 ) return result; 

+

+	fd->flags &= ~DFS_F_OPEN;

+

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_ioctl

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_ioctl(struct dfs_fd* fd, int cmd, void *args)

+{

+	struct dfs_filesystem* fs;

+

+	if (fd == RT_NULL || fd->type != FT_REGULAR) return -DFS_STATUS_EINVAL;

+

+	fs = fd->fs;

+#if 0 /* not support right now */

+	if (cmd == FILEGETSIZE)

+	{

+		if (args == RT_NULL) return -DFS_STATUS_EINVAL;

+

+		*((rt_uint32_t *) args) = fd->size;

+

+		return 0;

+	}

+	else if (cmd == FILEGETPOS)

+	{

+		if (args == RT_NULL) return -DFS_STATUS_EINVAL;

+

+		*((rt_uint32_t *) args) = fd->pos;

+

+		return 0;

+	}

+#endif

+

+	if (fs->ops->ioctl != RT_NULL) return fs->ops->ioctl(fd, cmd, args);

+

+	return -DFS_STATUS_ENOSYS;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_read

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_read(struct dfs_fd* fd, void *buf, rt_size_t len)

+{

+	struct dfs_filesystem* fs;

+	int result = 0;

+

+	if (fd == RT_NULL) return -DFS_STATUS_EINVAL;

+	

+	fs = (struct dfs_filesystem*) fd->fs;

+	if (fs->ops->read == RT_NULL) return -DFS_STATUS_ENOSYS;

+

+	if ( (result = fs->ops->read(fd, buf, len)) < 0 ) fd->flags |= DFS_F_EOF;

+

+	return result;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_getdents

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_getdents(struct dfs_fd* fd, struct dfs_dirent* dirp, rt_size_t nbytes)

+{

+	struct dfs_filesystem* fs;

+

+	/* parameter check */

+	if (fd == RT_NULL || fd->type != FT_REGULAR) return -DFS_STATUS_EINVAL;

+

+	fs = (struct dfs_filesystem*) fd->fs;

+	if (fs->ops->getdents != RT_NULL) return fs->ops->getdents(fd, dirp, nbytes);

+

+	return -DFS_STATUS_ENOSYS;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_unlink

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_unlink(const char *path)

+{

+	struct dfs_filesystem* fs;

+	char *fullpath, *real_path, search_path[DFS_PATH_MAX + 1];

+#ifdef RT_USING_WORKDIR	

+	char full_path[DFS_PATH_MAX+1];

+#endif

+	struct dfs_fd* fd;

+	int index, fspathlen;

+

+	/* Make sure we have an absolute path */

+	fullpath = (char*)path;

+	if ( fullpath[0] != '/')

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		fullpath = full_path;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, path, fullpath);

+		rt_sem_release(working_directory_lock);

+#else

+#ifdef RT_USING_FINSH

+		rt_kprintf("bad filename");

+#endif

+		return -1;

+#endif

+	}

+

+	if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL) return -DFS_STATUS_ENOENT;

+

+	/* Check whether file is already open */

+	rt_sem_take(fd_table_lock, RT_WAITING_FOREVER);

+	for (index = 0; index < DFS_FD_MAX; index++)

+	{

+		fd = &(fd_table[index]);

+		if (fd->fs == RT_NULL) continue;

+

+		build_fullpath(fd->fs->path, fd->path, search_path);

+		if (strcmp(fullpath, search_path) == 0)

+		{

+			rt_sem_release(fd_table_lock);

+			return -DFS_STATUS_EEXIST;

+		}

+	}

+	rt_sem_release(fd_table_lock);

+

+	fspathlen = strlen(fs->path);

+	real_path = search_path;

+	rt_memset( real_path, 0, sizeof( real_path ) );

+	if (*(fullpath + fspathlen) != '/') strcpy(real_path, "/");

+	strcat(real_path, fullpath + fspathlen);

+

+	if (fs->ops->unlink != RT_NULL) return fs->ops->unlink(fs, real_path);

+

+	return -DFS_STATUS_ENOSYS;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_write

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_write(struct dfs_fd* fd, const void *buf, rt_size_t len)

+{

+	struct dfs_filesystem* fs = fd->fs;

+

+	if (fd == RT_NULL) return -DFS_STATUS_EINVAL;

+	if (fs->ops->write == RT_NULL) return -DFS_STATUS_ENOSYS;

+

+	return fs->ops->write(fd, buf, len);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_lseek

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_lseek(struct dfs_fd* fd, rt_off_t offset)

+{

+	struct dfs_filesystem* fs = fd->fs;

+

+	if (fd == RT_NULL) return -DFS_STATUS_EINVAL;

+	if (fs->ops->lseek == RT_NULL) return -DFS_STATUS_ENOSYS;

+

+	return fs->ops->lseek(fd, offset);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_stat

++------------------------------------------------------------------------------

+| Description : get the file or directory stat description

+|

+| Parameters  : path, the file or directory path

+|               buf,  the stat description will be saved in it

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_stat(const char *path, struct dfs_stat *buf)

+{

+	struct dfs_filesystem* fs;

+	char* fullpath, real_path[DFS_PATH_MAX + 1];

+#ifdef RT_USING_WORKDIR	

+	char full_path[DFS_PATH_MAX + 1];

+#endif

+	int fspathlen;

+

+	fullpath = (char*)path;

+	if ( fullpath[0] != '/' )

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		fullpath = full_path;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, path, fullpath);

+		rt_sem_release(working_directory_lock);

+#else

+#ifdef RT_USING_FINSH

+		rt_kprintf("bad filename");

+#endif

+		return -1;

+#endif

+	}

+

+	if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL )

+	{

+		dfs_log(DFS_DEBUG_ERROR, ("can't find mounted filesystem on this path:%s", fullpath));

+		return -DFS_STATUS_ENOENT;

+	}

+

+	fspathlen = strlen(fs->path);

+	rt_memset(real_path, 0, sizeof(real_path));

+	if (*(fullpath + fspathlen) != '/') strcpy(real_path, "/");

+	strcat(real_path, fullpath + fspathlen);

+

+	if (fs->ops->stat == RT_NULL)

+	{

+		dfs_log(DFS_DEBUG_ERROR, ("the filesystem didn't implement this function"));

+		return -DFS_STATUS_ENOSYS;

+	}

+

+	return fs->ops->stat(fs, real_path, buf);

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : dfile_raw_rename

++------------------------------------------------------------------------------

+| Description : 

+|

+| Parameters  : 

+| Returns     : 

+|

++------------------------------------------------------------------------------

+*/

+int dfile_raw_rename(const char* oldpath, const char* newpath)

+{

+	struct dfs_filesystem *oldfs, *newfs;

+	char *oldfullpath, *newfullpath;

+	#ifdef RT_USING_WORKDIR	

+	/* Change DFS_PATH_MAX to DFS_PATH_MAX + 1, [email protected]*/

+	char old_realpath[DFS_PATH_MAX + 1], new_realpath[DFS_PATH_MAX + 1];

+	#endif

+

+	oldfullpath = (char*)oldpath;

+	newfullpath = (char*)newpath;

+

+	if ( oldfullpath[0] != '/' )

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		oldfullpath = old_realpath;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, oldpath, oldfullpath);

+		rt_sem_release(working_directory_lock);

+#else

+#ifdef RT_USING_FINSH

+		rt_kprintf("bad filename");

+#endif

+		return -1;

+#endif

+	}

+

+	if ( newfullpath[0] != '/' )

+	{

+#ifdef RT_USING_WORKDIR	

+		/* build full path */

+		newfullpath = new_realpath;

+		rt_sem_take(working_directory_lock, RT_WAITING_FOREVER);

+		build_fullpath(working_directory, newpath, newfullpath);

+		rt_sem_release(working_directory_lock);

+#else

+#ifdef RT_USING_FINSH

+		rt_kprintf("bad filename");

+#endif

+		return -1;

+#endif

+	}

+

+	if ( (oldfs = dfs_filesystem_lookup(oldfullpath)) == RT_NULL )

+	{

+		return -DFS_STATUS_ENOENT;

+	}

+

+	if ( (newfs = dfs_filesystem_lookup(newfullpath)) == RT_NULL )

+	{

+		return -DFS_STATUS_ENOENT;

+	}

+

+	if ( oldfs == newfs )

+	{

+		if ( oldfs->ops->rename == RT_NULL ) return -DFS_STATUS_ENOSYS;

+		

+		return oldfs->ops->rename(oldfs, oldfullpath, newfullpath);

+	}

+

+	/* not at same file system, return EXDEV */

+	return -DFS_STATUS_EXDEV;

+}

+

+#ifdef RT_USING_FINSH

+#include <finsh.h>

+

+static char fullpath[256 + 1];

+static struct dfs_fd fd;

+static struct dfs_dirent dirent;

+void __ls(const char* pathname)

+{

+	struct dfs_stat stat;

+	int length;

+

+	/* list directory */

+	if ( dfile_raw_open(&fd, pathname, DFS_O_DIRECTORY) == 0 )

+	{

+		rt_kprintf("Directory %s:\n", pathname);

+		do

+		{

+			rt_memset(&dirent, 0, sizeof(struct dfs_dirent));

+			length = dfile_raw_getdents(&fd, &dirent, sizeof(struct dfs_dirent));

+			if ( length > 0 ) 

+			{

+				rt_memset(&stat, 0, sizeof(struct dfs_stat));

+				

+				/* build full path for each file */

+				strncpy(fullpath, pathname, 256);

+				strcat(fullpath, "/");

+				strcat(fullpath, dirent.d_name);

+				

+				dfile_raw_stat(fullpath, &stat);

+				if ( stat.st_mode & DFS_S_IFDIR )

+				{

+					rt_kprintf("%s\t\t<DIR>\n", dirent.d_name);

+				}

+				else

+				{

+					rt_kprintf("%s\t\t%lu\n", dirent.d_name, stat.st_size);

+				}

+			}

+		}while(length > 0);

+

+		dfile_raw_close(&fd);

+	}

+	else

+	{

+		rt_kprintf("No such directory\n");

+	}

+}

+FINSH_FUNCTION_EXPORT(__ls, list directory contents)

+

+void __mkdir(const char* pathname)

+{

+	/* make a new directory */

+	if (dfile_raw_open(&fd, pathname, DFS_O_DIRECTORY | DFS_O_CREAT) == 0)

+	{

+		dfile_raw_close(&fd);

+	}

+	else rt_kprintf("Can't mkdir %s\n", pathname);

+}

+FINSH_FUNCTION_EXPORT(__mkdir, make a directory)

+

+void __rm(const char* filename)

+{

+	if (dfile_raw_unlink(filename) < 0)

+	{

+		rt_kprintf("Delete %s failed\n", filename);

+	}

+}

+FINSH_FUNCTION_EXPORT(__rm, remove files or directories)

+

+void __cat(const char* filename)

+{

+	rt_uint32_t length;

+	char buffer[81];

+	

+	if (dfile_raw_open(&fd, filename, DFS_O_RDONLY) < 0)

+	{

+		rt_kprintf("Open %s failed\n", filename);

+		return;

+	}

+	

+	do

+	{

+		rt_memset(buffer, 0, sizeof(buffer));

+		length = dfile_raw_read(&fd, buffer, 81);

+		if (length > 0)

+		{

+			rt_kprintf("%s", buffer);

+		}

+	}while (length > 0);

+	

+	dfile_raw_close(&fd);

+}

+FINSH_FUNCTION_EXPORT(__cat, print file)

+

+#ifndef FINSH_USING_SYMTAB

+void dfs_export_finsh(void)

+{

+	finsh_syscall_append("ls", (syscall_func)__ls);

+	finsh_syscall_append("mkdir", (syscall_func)__mkdir);

+	finsh_syscall_append("rm", (syscall_func)__rm);

+	finsh_syscall_append("cat", (syscall_func)__cat);

+}

+#endif

+#endif

diff --git a/filesystem/dfs/src/dfs_util.c b/filesystem/dfs/src/dfs_util.c
new file mode 100644
index 0000000000..455c9f1f9d
--- /dev/null
+++ b/filesystem/dfs/src/dfs_util.c
@@ -0,0 +1,297 @@
+/*

++------------------------------------------------------------------------------

+| Project   : Device Filesystem

++------------------------------------------------------------------------------

+| Copyright 2004, 2005  www.fayfayspace.org.

+| All rights reserved.

+|------------------------------------------------------------------------------

+| File      : dfs_utl.c, some misc functions of Device FileSystem

+|------------------------------------------------------------------------------

+| Chang Logs:

+| Date           Author       Notes

+| 2005-01-26     ffxz		  The first version

++------------------------------------------------------------------------------

+*/

+

+#include <string.h>

+

+#include <dfs_fs.h>

+#include <dfs_util.h>

+

+/*

++------------------------------------------------------------------------------

+| Function    : dir_name

++------------------------------------------------------------------------------

+| Description : Gets the directory name in specified path string

+|

+| Parameters  : path, the specified path string

+|               path_name, return the path name in this parameter

+|               len, the length of path name

+| Returns     : the status of path_name:

+|               0 , successful

+|               -1, failed

+| For Example :

+| path,			dir_name

+| /,			/

+| /usr,			/

+| /usr/lib,		/usr

+| /usr/lib/,	/usr

++------------------------------------------------------------------------------

+*/

+int dir_name(const char* path, char* dirname, int len)

+{

+	int pos;

+

+	if ( path[0] == '/' && path[1] == '\0' )

+	{

+		*dirname++ = '/';

+		*dirname = '\0';

+		return 0;

+	}

+

+	pos = strlen(path);

+	while ( *(path + pos - 1) =='/' ) pos --;

+	while ( pos > 0 && *(path + pos - 1) != '/' ) pos --;

+	while ( pos > 0 && *(path + pos - 1) == '/' ) pos --;

+

+	if ( pos > len ) return -1;

+

+	if ( pos != 0) 

+	{

+		memcpy(dirname, path, pos);

+		*(dirname+pos) = '\0';

+	}

+	else 

+	{

+		*dirname++ = '/';

+		*dirname   = '\0';

+	}

+

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : file_name

++------------------------------------------------------------------------------

+| Description : Gets the file name in specified path string

+|

+| Parameters  : path, the specified path string

+|               filename, return the path name in this parameter

+|               len, the length of file name

+| Returns     : the status of file_name:

+|               0 , successful

+|               -1, failed

+| For Example :

+| path,			filename

+| /,			RT_NULL

+| /usr,			usr

+| /usr/lib,		lib

+| /usr/lib/,	lib

++------------------------------------------------------------------------------

+*/

+int file_name(const char* path, char* filename, int len)

+{

+	int pos, size;

+

+	if ( path[0] == '/' && path[1] == '\0' )

+	{

+		*filename = '\0';

+		return 0;

+	}

+

+	pos = strlen(path);

+	while ( *(path + pos -1)=='/' ) pos --;

+	size = pos;

+

+	while ( *(path + pos -1) != '/' && pos > 0 ) pos --;

+

+	if ( size - pos > len ) return -1;

+	else size = size - pos ;

+

+	memcpy(filename, path + pos, size);

+	*(filename+size) = '\0';

+

+	return 0;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : next_path_name

++------------------------------------------------------------------------------

+| Description : Gets the next directory name from specified path string

+|

+| Parameters  : path, the specified path string

+|               pos, the specified position of path string

+|               next, return the next path in this parameter

+| Returns     : the position of next directory item, 

+|               -1, if pos reach in the end of the specified path string

+| For Example :

++------------------------------------------------------------------------------

+*/

+int next_dir_name(const char* path, int pos, char* next)

+{

+	const char* q;

+

+	if ( pos > strlen(path) || pos < 0|| path == RT_NULL ) return -1;

+

+	q = path + pos;

+

+	/* check for firt '/' */

+	while ( *q == '/' ) q++;

+	if ( *q == '\0' )

+	{

+		*next = '\0';

+		return -1;

+	}

+

+	while ( *q != '/' && *q != '\0' )

+	{

+		*next++ = *q++;

+	}

+	*next = '\0';

+

+	return q - path + 1;

+}

+

+/*

++------------------------------------------------------------------------------

+| Function    : build_fullpath

++------------------------------------------------------------------------------

+| Description : make up the full path from directory and filename

+|

+| Parameters  : path, the specified path string

+|               filename, return the path name in this parameter

+|               fullpath, the returned full path name

+| Returns     : null

++------------------------------------------------------------------------------

+*/

+void build_fullpath(const char *directory, const char *filename, char *fullpath)

+{

+	char elem[DFS_PATH_MAX + 1];

+	int pos, start, len;

+

+	len = 0;

+	/* check parameters */

+	RT_ASSERT(directory != RT_NULL);

+	RT_ASSERT(filename != RT_NULL);

+	RT_ASSERT(fullpath != RT_NULL);

+

+	/* copy full of directory */

+	strncpy(fullpath, directory, DFS_PATH_MAX + 1);

+

+	for (pos = 0; filename[pos] != '\0'; )

+	{

+		/* strip '//' */

+		while (filename[pos] == '/') pos++;

+

+		/* get the filename element, save to elem array */

+		for (start = pos; filename[pos] != '/' && filename[pos] != '\0'; pos++)

+			len = pos - start + 1;

+

+		strncpy(elem, filename + start, DFS_PATH_MAX + 1);

+		/* clear the end of elem */

+		elem[(len < DFS_PATH_MAX + 1? len : DFS_PATH_MAX + 1)] = '\0';

+

+		/* strip '..' */

+		if (elem[0] == '.' && elem[1] == '.')

+		{

+			if (strlen(fullpath) == 0) strcpy(fullpath, ""); /* empty filename */

+			else if (fullpath[0] == '/' && fullpath[1] !='\0')

+			{

+				int i = strlen(fullpath);

+

+				while (fullpath[i - 1] == '/') i--;

+				while (i > 0 && fullpath[i - 1] != '/') i--;

+

+				fullpath[i] = '\0';

+			}

+		}

+		/* not '.', copy as normally */

+		else if (elem[0] != '.')

+		{

+			len = strlen(fullpath);

+			

+			if (len == 0) strncpy(fullpath, elem, DFS_PATH_MAX + 1);

+			else if (fullpath[len - 1] == '/')

+			{

+				if (elem[0] == '/') strncat(fullpath, elem + 1, DFS_PATH_MAX + 1);

+				else strncat(fullpath, elem, DFS_PATH_MAX + 1);

+			}

+			else

+			{

+				if (elem[0] == '/') strcat(fullpath, elem);

+				else

+				{

+					strncat(fullpath, "/", DFS_PATH_MAX + 1);

+					strncat(fullpath + 1, elem, DFS_PATH_MAX + 1);

+				}

+			}

+		}

+	}

+

+	if ( fullpath[0] != '/' && fullpath[(len = strlen(fullpath)) - 1] == '/')

+	{

+		fullpath[len - 1] = '\0';

+	}

+}

+

+int str_is_prefix(const char* prefix, const char* str)

+{

+	while ((*prefix) && (*str) && (*prefix == *str))

+	{

+		prefix ++;

+		str ++;

+	}

+	

+	if (*prefix == 0) return 0;

+	

+	return -1;

+}

+

+#if !defined(RT_USING_MINILIBC) && !defined(RT_USING_NEWLIB)

+#if !defined(__ICCARM__)

+char *strrchr(const char *t, int c)

+{

+	register char ch;

+	register const char *l=0;

+

+	ch = c;

+	for (;;)

+	{

+		if ((*t == ch)) l=t;

+		if ((!*t)) return (char*)l; ++t;

+	}

+

+	return (char*)l;

+}

+#endif

+

+#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION / 10000 < 35)

+int  strncasecmp ( const char* s1, const char* s2, size_t len )

+{

+    register unsigned int  x2;

+    register unsigned int  x1;

+    register const char*   end = s1 + len;

+

+    while (1)

+	{

+        if ((s1 >= end) )

+            return 0;

+        

+		x2 = *s2 - 'A'; if ((x2 < 26u)) x2 += 32;

+        x1 = *s1 - 'A'; if ((x1 < 26u)) x1 += 32;

+		s1++; s2++;

+		

+        if ((x2 != x1))

+            break;

+			

+        if ((x1 == (unsigned int)-'A'))

+            break;

+    }

+

+    return x1 - x2;

+}

+#endif /* end of __ARMCC_VERSION */

+

+#endif