add yaffs code and modify dfs/SConscript for yaffs

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

3 files changed, 996 insertions, 23 deletions

diff --git a/components/dfs/SConscript b/components/dfs/SConscript
index 2069ae7e0b..9d51586886 100644
--- a/components/dfs/SConscript
+++ b/components/dfs/SConscript
@@ -32,28 +32,30 @@ filesystems/devfs/console.c
 # DFS-YAFFS2 options

 yaffs2_src = Split("""

 filesystems/yaffs2/dfs_yaffs2.c

-filesystems/yaffs2/yaffs_nand_config.c

 filesystems/yaffs2/yaffs_osglue.c

+filesystems/yaffs2/yaffs_nandcfg.c

+

+filesystems/yaffs2/yaffs/yaffs_allocator.c

+filesystems/yaffs2/yaffs/yaffs_bitmap.c

+filesystems/yaffs2/yaffs/yaffs_checkptrw.c

+filesystems/yaffs2/yaffs/yaffs_ecc.c  

+filesystems/yaffs2/yaffs/yaffs_guts.c

+filesystems/yaffs2/yaffs/yaffs_nameval.c

+filesystems/yaffs2/yaffs/yaffs_nand.c

+filesystems/yaffs2/yaffs/yaffs_packedtags1.c

+filesystems/yaffs2/yaffs/yaffs_packedtags2.c

+filesystems/yaffs2/yaffs/yaffs_summary.c

+filesystems/yaffs2/yaffs/yaffs_tagscompat.c

+filesystems/yaffs2/yaffs/yaffs_verify.c

+filesystems/yaffs2/yaffs/yaffs_yaffs1.c

+filesystems/yaffs2/yaffs/yaffs_yaffs2.c

+

+filesystems/yaffs2/yaffs/direct/yaffs_attribs.c

+filesystems/yaffs2/yaffs/direct/yaffs_hweight.c

+filesystems/yaffs2/yaffs/direct/yaffs_nandif.c

+filesystems/yaffs2/yaffs/direct/yaffs_qsort.c

+filesystems/yaffs2/yaffs/direct/yaffsfs.c

 

-filesystems/yaffs2/yaffs_allocator.c

-filesystems/yaffs2/yaffs_bitmap.c

-filesystems/yaffs2/yaffs_checkptrw.c

-filesystems/yaffs2/yaffs_ecc.c  

-filesystems/yaffs2/yaffs_guts.c

-filesystems/yaffs2/yaffs_nameval.c

-filesystems/yaffs2/yaffs_nand.c

-filesystems/yaffs2/yaffs_packedtags1.c

-filesystems/yaffs2/yaffs_packedtags2.c

-filesystems/yaffs2/yaffs_summary.c

-filesystems/yaffs2/yaffs_tagscompat.c

-filesystems/yaffs2/yaffs_verify.c

-filesystems/yaffs2/yaffs_yaffs1.c

-filesystems/yaffs2/yaffs_yaffs2.c

-filesystems/yaffs2/yaffs_attribs.c

-filesystems/yaffs2/yaffsfs.c

-filesystems/yaffs2/yaffs_hweight.c

-filesystems/yaffs2/yaffs_nandif.c

-filesystems/yaffs2/yaffs_qsort.c

 """)

 

 nfs = Split('''

@@ -143,9 +145,10 @@ CPPDEFINES = []
 # The set of source files associated with this SConscript file.

 path = [RTT_ROOT + '/components/dfs', RTT_ROOT + '/components/dfs/include']

 

-#if GetDepend('RT_USING_DFS_YAFFS2'):

-#    src_local = src_local + yaffs2_src

-#    path = path + [RTT_ROOT + '/components/dfs/filesystems/yaffs2']

+if GetDepend('RT_USING_DFS_YAFFS2'):

+    src_local = src_local + yaffs2_src

+    path = path + [RTT_ROOT + '/components/dfs/filesystems/yaffs2/yaffs', \

+                   RTT_ROOT + '/components/dfs/filesystems/yaffs2/yaffs/direct' ]

 

 if GetDepend('RT_USING_DFS_ELMFAT'):

     if GetDepend('RT_DFS_ELM_USE_LFN'):

diff --git a/components/dfs/filesystems/yaffs2/readme.txt b/components/dfs/filesystems/yaffs2/readme.txt
new file mode 100644
index 0000000000..b4369a52e1
--- /dev/null
+++ b/components/dfs/filesystems/yaffs2/readme.txt
@@ -0,0 +1,41 @@
+how to use yaffs under rt-thread.

+

+There are three steps.

+1. get yaffs tarball from official repo.

+   the repo of official repo is here.

+     http://www.aleph1.co.uk/gitweb?p=yaffs2.git;a=summary

+   then you should find the 2011-6-28's snapshot, download the tarball

+     http://www.aleph1.co.uk/gitweb?p=yaffs2.git;a=snapshot;h=2df51cdb98e799c4d10b4cc7dd7e8858aa79e7d8;sf=tgz

+  

+   decompress the yaffs.tar.gz to rt-thread\components\dfs\filesystems\yaffs2\yaffs

+

+2. patch yaffs.diff    

+    open an terminal.

+    (1) on windows

+       open cmd command prompt, then use [cd] command to come current path

+       for example 

+         F:\Project\svn\rt-thread\components\dfs\filesystems\yaffs2>

+       then type command 

+         patch -p1 < yaffs.diff

+       you will get some log information as followings 

+         F:\Project\svn\rt-thread\components\dfs\filesystems\yaffs2>patch -p1 < yaffs.diff

+         patching file `dfs_yaffs2.c'

+         patching file `yaffs/direct/yaffs_list.h'

+         patching file `yaffs/direct/yaffs_nandif.c'

+         patching file `yaffs/direct/ydirectenv.h'

+         patching file `yaffs/direct/yportenv.h'

+         patching file `yaffs_nandcfg.c'

+         patching file `yaffs_osglue.c'

+

+       now you can delete yaffs.diff

+

+    (2) on linux

+       Help yourself. Since you have use linux as your os, I believe in you. 

+

+3.add nand driver and compile 

+    In order to use yaffs, you should provide a nand driver which is needed

+    by yaffs. There is an example file in rt-thread\components\dfs\filesystems\uffs\nand.

+    you should modify yaffs_nandcfg.c according to your nand driver.

+ then you can use scons or IDE like MDK or IAR to compile.

+

+ enjoy !

diff --git a/components/dfs/filesystems/yaffs2/yaffs.diff b/components/dfs/filesystems/yaffs2/yaffs.diff
new file mode 100644
index 0000000000..4d6be15100
--- /dev/null
+++ b/components/dfs/filesystems/yaffs2/yaffs.diff
@@ -0,0 +1,929 @@
+diff --git a/dfs_yaffs2.c b/dfs_yaffs2.c
+new file mode 100644
+index 0000000..4b056ae
+--- /dev/null
++++ b/dfs_yaffs2.c
+@@ -0,0 +1,405 @@
++/*
++ * File      : rtthread.h
++ * This file is part of RT-Thread RTOS
++ * COPYRIGHT (C) 2006-2011, RT-Thread Development Team
++ *
++ * The license and distribution terms for this file may be
++ * found in the file LICENSE in this distribution or at
++ * http://www.rt-thread.org/license/LICENSE.
++ *
++ * Change Logs:
++ * Date           Author       Notes
++ * 2011-10-22     prife        the first version
++ * 2012-04-14     prife        use mtd device interface
++*/
++#include <rtthread.h>
++#include <rtdevice.h>
++
++#include "yaffsfs.h"
++#include "yaffs_nandif.h"
++
++#include <dfs_fs.h>
++#include <dfs_def.h>
++
++#define YAFFS_FILE_PATH_MAX	             256 /* the longest file path */
++
++#define NAND_DEVICE_PART_MAX   4  /* the max partitions on a nand deivce*/
++struct device_part
++{
++	struct rt_mtd_nand_device *dev;
++	ynandif_Geometry g;
++};
++static struct device_part nand_part[NAND_DEVICE_PART_MAX] = {0};
++
++extern int yaffs_start(const char * mountpath, ynandif_Geometry * g);
++extern void yaffs_config(ynandif_Geometry * g, struct rt_mtd_nand_device * dev);
++
++static int dfs_yaffs_mount(struct dfs_filesystem* fs,
++                    unsigned long rwflag, 
++				    const void* data)
++{
++	unsigned index;
++	ynandif_Geometry *g;
++
++	/*1. find a empty entry in partition table */
++	for (index = 0; index < NAND_DEVICE_PART_MAX ; index ++)
++	{
++		if (nand_part[index].dev == RT_NULL)
++			break;
++	}
++	if (index == NAND_DEVICE_PART_MAX)
++		return -DFS_STATUS_ENOSPC;
++
++	/*2. fill nand_part*/
++	nand_part[index].dev = RT_MTD_NAND_DEVICE(fs->dev_id);
++	yaffs_config(&nand_part[index].g, RT_MTD_NAND_DEVICE(fs->dev_id));
++
++	/*3. start up yaffs2 */
++	yaffs_start(fs->path, &nand_part[index].g);
++	if (yaffs_mount(fs->path) < 0)
++	{	
++		return yaffsfs_GetLastError();
++	}
++	return 0;
++}
++
++static int dfs_yaffs_unmount(struct dfs_filesystem* fs)
++{
++	unsigned index;
++	if (yaffs_unmount(fs->path) < 0)
++		return yaffsfs_GetLastError();
++
++	/* find device index, then umount it */
++	for (index = 0; index < NAND_DEVICE_PART_MAX; index++)
++	{
++		if (nand_part[index].dev == RT_MTD_NAND_DEVICE(fs->dev_id))
++		{
++			nand_part[index].dev = RT_NULL;
++			return DFS_STATUS_OK;
++		}
++	}
++	return -DFS_STATUS_ENOENT;
++}
++
++static int dfs_yaffs_mkfs(const char* device_name)
++{
++	/* just erase all blocks on this nand partition */
++	return -DFS_STATUS_ENOSYS; 
++}
++
++static int dfs_yaffs_statfs(struct dfs_filesystem* fs,
++                     struct statfs *buf)
++{
++	struct rt_mtd_nand_device * mtd = RT_MTD_NAND_DEVICE(fs->dev_id);
++
++	RT_ASSERT(mtd != RT_NULL);
++
++	buf->f_bsize = mtd->page_size;
++	buf->f_blocks = (mtd->block_size)/(mtd->page_size)*
++	                (mtd->block_start - mtd->block_end + 1);
++	buf->f_bfree = yaffs_freespace(fs->path) / mtd->page_size;
++
++	return 0;
++}
++
++static int dfs_yaffs_open(struct dfs_fd* file)
++{
++	int fd;
++	int oflag;
++	int result;
++		
++	oflag = file->flags;
++	if (oflag & DFS_O_DIRECTORY) /* operations about dir */
++	{
++		yaffs_DIR * dir;
++		if (oflag & DFS_O_CREAT) /* create a dir*/
++		{	
++			result = yaffs_mkdir(file->path, 0x777); /* the second args not supported by rtt */
++			if (result < 0)
++				return yaffsfs_GetLastError();
++		}
++		/* open dir */
++		dir = yaffs_opendir(file->path);
++		if (dir == RT_NULL)
++			return yaffsfs_GetLastError();			
++		/* save this pointer,will used by dfs_yaffs_getdents*/
++		file->data = dir;
++		return 0;
++	} 
++	/* regular file operations */
++	fd = yaffs_open(file->path, oflag, S_IREAD | S_IWRITE); 	
++	if (fd < 0)
++		return yaffsfs_GetLastError();
++
++	 /* save this pointer, it will be used when calling read()��write(), 
++	 flush(), lessk(), and will be free when calling close()*/
++	file->data = (void *)fd;
++	file->pos  = yaffs_lseek(fd,0,SEEK_CUR); 
++	file->size = yaffs_lseek(fd,0,SEEK_END);
++	yaffs_lseek(fd, file->pos, SEEK_SET);
++
++	if (oflag & DFS_O_APPEND)
++	{
++		file->pos = file->size;	
++		file->size = yaffs_lseek(fd,0,SEEK_END);
++	}
++	return 0; 
++}
++
++static int dfs_yaffs_close(struct dfs_fd* file)
++{
++	int oflag;
++	int fd;
++	
++	oflag = file->flags;
++	if (oflag & DFS_O_DIRECTORY) /* operations about dir */
++	{
++		if (yaffs_closedir((yaffs_DIR *)(file->data)) < 0)
++			return yaffsfs_GetLastError();	
++		return 0;
++	}
++	/* regular file operations */
++	fd = (int)(file->data);
++
++	if (yaffs_close(fd) == 0)
++		return 0;
++
++	/* release memory */
++	return yaffsfs_GetLastError();
++}
++
++static int dfs_yaffs_ioctl(struct dfs_fd* file, int cmd,	void* args)
++{
++	return -DFS_STATUS_ENOSYS;
++}
++
++static int dfs_yaffs_read(struct dfs_fd* file, void* buf, rt_size_t len)
++{
++	int fd;
++	int char_read;
++	
++	fd = (int)(file->data);
++	char_read = yaffs_read(fd, buf, len);
++	if (char_read < 0) 
++		return yaffsfs_GetLastError();
++	
++	/* update position */
++	file->pos = yaffs_lseek(fd, 0, SEEK_CUR);
++	return char_read;
++}
++
++static int dfs_yaffs_write(struct dfs_fd* file,
++                    const void* buf, 
++					rt_size_t len)
++{
++	int fd;
++	int char_write;
++	
++	fd = (int)(file->data);
++	
++	char_write = yaffs_write(fd, buf, len);
++	if (char_write < 0) 
++		return yaffsfs_GetLastError();
++	
++	/* update position */
++	file->pos = yaffs_lseek(fd, 0, SEEK_CUR);
++	return char_write;
++}
++
++static int dfs_yaffs_flush(struct dfs_fd* file)
++{
++	int fd;
++	int result;
++	
++	fd = (int)(file->data);
++
++	result = yaffs_flush(fd);
++	if (result < 0)
++		return yaffsfs_GetLastError();
++	return 0;
++}
++
++static int dfs_yaffs_lseek(struct dfs_fd* file,
++                    rt_off_t offset)
++{
++	int fd;
++	int result;
++	
++	fd = (int)(file->data);
++
++	/* set offset as current offset */
++	result = yaffs_lseek(fd, offset, SEEK_SET);
++	if (result < 0)
++		return yaffsfs_GetLastError();
++	return result;
++}
++
++/* return the size of  struct dirent*/
++static int dfs_yaffs_getdents(struct dfs_fd* file,
++                       struct dirent* dirp, 
++					   rt_uint32_t count)
++{
++	rt_uint32_t index;
++	char * file_path;	
++	struct dirent* d;
++	yaffs_DIR* dir;
++	struct yaffs_dirent * yaffs_d;	
++		
++	dir = (yaffs_DIR*)(file->data);
++	RT_ASSERT(dir != RT_NULL);
++
++	/* make integer count, usually count is 1 */
++	count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
++	if (count == 0) return -DFS_STATUS_EINVAL;
++
++	/* allocate file name */
++	file_path = rt_malloc(YAFFS_FILE_PATH_MAX);
++	if (file_path == RT_NULL)
++		return -DFS_STATUS_ENOMEM;
++	
++	index = 0;
++	/* usually, the while loop should only be looped only once! */
++	while (1)
++	{
++		struct yaffs_stat s; 
++		
++		d = dirp + index;
++
++		yaffs_d = yaffs_readdir(dir);
++		if (yaffs_d == RT_NULL)
++		{
++			if (yaffsfs_GetLastError() == EBADF)
++				return -DFS_STATUS_EBADF;
++
++			rt_free(file_path);
++			return -1; /* a general error */
++		}
++		
++		rt_snprintf(file_path, YAFFS_FILE_PATH_MAX, "%s/%s", file->path, yaffs_d->d_name);
++
++		yaffs_lstat(file_path, &s); 	 
++		switch(s.st_mode & S_IFMT) 
++		{ 
++		case S_IFREG: d->d_type = DFS_DT_REG; break; 
++		
++		case S_IFDIR: d->d_type = DFS_DT_DIR; break; 
++		
++		case S_IFLNK:
++		default: d->d_type = DFS_DT_UNKNOWN; break; 
++		} 	
++
++		/* write the rest feilds of struct dirent* dirp  */
++		d->d_namlen = rt_strlen(yaffs_d->d_name);
++		d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
++		rt_strncpy(d->d_name, yaffs_d->d_name, rt_strlen(yaffs_d->d_name) + 1);
++		
++		index ++;
++		if (index * sizeof(struct dirent) >= count)
++			break;
++	}
++
++	/* free file name buf */
++	rt_free(file_path);
++	
++	if (index == 0)
++		return yaffsfs_GetLastError();
++
++	return index * sizeof(struct dirent);
++}
++
++static int dfs_yaffs_unlink(struct dfs_filesystem* fs, const char* path)
++{
++	int result;
++	struct yaffs_stat s;
++
++	/* judge file type, dir is to be delete by yaffs_rmdir, others by yaffs_unlink */
++	if (yaffs_lstat(path, &s) < 0) 
++	{
++		return yaffsfs_GetLastError();
++	}
++	
++	switch(s.st_mode & S_IFMT) 
++	{ 
++	case S_IFREG: 
++		result = yaffs_unlink(path); 
++		break; 	
++	case S_IFDIR: 
++		result = yaffs_rmdir(path);		
++		break;
++	default: 
++		/* unknown file type */
++		return -1;
++	} 
++	if (result < 0) 
++		return yaffsfs_GetLastError();
++	return 0;			
++}
++
++static int dfs_yaffs_rename(struct dfs_filesystem* fs,
++                     const char* oldpath,
++					 const char* newpath)
++{
++	int result;
++
++	result = yaffs_rename(oldpath, newpath);
++
++	if (result < 0)
++		return yaffsfs_GetLastError();
++	return 0;
++}
++
++static int dfs_yaffs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st)
++{
++	int result;
++	struct yaffs_stat s;
++	struct rt_mtd_nand_device * mtd;
++	
++	result = yaffs_stat(path, &s);
++	if (result < 0)
++		return yaffsfs_GetLastError(); 
++
++	/* convert to dfs stat structure */
++	st->st_dev  = 0;
++	st->st_mode = s.st_mode;
++	st->st_size = s.st_size;
++	st->st_mtime = s.yst_mtime;
++
++	mtd = RT_MTD_NAND_DEVICE(fs->dev_id);
++	st->st_blksize = mtd->page_size;
++
++	return 0;
++}
++
++static const struct dfs_filesystem_operation dfs_yaffs_ops = 
++{
++	"yaffs2", /* file system type: yaffs2 */
++#if RTTHREAD_VERSION >= 10100
++	DFS_FS_FLAG_FULLPATH,
++#else
++#error "yaffs2 can only work with rtthread whose version should >= 1.01\n"
++#endif
++	dfs_yaffs_mount,
++	dfs_yaffs_unmount,
++	dfs_yaffs_mkfs,
++	dfs_yaffs_statfs,
++
++	dfs_yaffs_open,
++	dfs_yaffs_close,
++	dfs_yaffs_ioctl,
++	dfs_yaffs_read,
++	dfs_yaffs_write,
++	dfs_yaffs_flush,
++	dfs_yaffs_lseek,
++	dfs_yaffs_getdents,
++	dfs_yaffs_unlink,
++	dfs_yaffs_stat,
++	dfs_yaffs_rename,
++};
++
++int dfs_yaffs_init(void)
++{
++    /* register fatfs file system */
++    dfs_register(&dfs_yaffs_ops);
++
++	return 0;
++}
+diff --git a/yaffs/direct/yaffs_list.h b/yaffs/direct/yaffs_list.h
+index f1c5254..17044f5 100644
+--- a/yaffs/direct/yaffs_list.h
++++ b/yaffs/direct/yaffs_list.h
+@@ -39,7 +39,7 @@ struct list_head {
+ 
+ /* Initialise a static list */
+ #define LIST_HEAD(name) \
+-struct list_head name = { &(name), &(name)}
++static struct list_head name = { &(name), &(name)}
+ 
+ 
+ 
+diff --git a/yaffs/direct/yaffs_nandif.c b/yaffs/direct/yaffs_nandif.c
+index b93b55a..3fae80e 100644
+--- a/yaffs/direct/yaffs_nandif.c
++++ b/yaffs/direct/yaffs_nandif.c
+@@ -18,7 +18,6 @@
+ #include "yaffs_nandif.h"
+ #include "yaffs_packedtags2.h"
+ 
+-#include "yramsim.h"
+ 
+ #include "yaffs_trace.h"
+ #include "yaffsfs.h"
+@@ -216,8 +215,8 @@ struct yaffs_dev *
+ 	yaffs_add_dev_from_geometry(const YCHAR *name,
+ 					const ynandif_Geometry *geometry)
+ {
+-	YCHAR *clonedName = malloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
+-	struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
++	YCHAR *clonedName = kmalloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1), GFP_NOFS);
++	struct yaffs_dev *dev = kmalloc(sizeof(struct yaffs_dev), GFP_NOFS);
+ 
+ 	if(dev && clonedName){
+ 		memset(dev,0,sizeof(struct yaffs_dev));
+@@ -242,16 +241,17 @@ struct yaffs_dev *
+ 		dev->param.n_reserved_blocks	  = 5;
+ 		dev->driver_context		  = (void *)geometry;
+ 
++		/* save rt_mtd_nand_device * dev*/
++		dev->os_context		  = (void *)(geometry->privateData);
+ 		yaffs_add_device(dev);
+ 
+ 		return dev;
+ 	}
+ 
+ 	if(dev)
+-		free(dev);
++		kfree(dev);
+ 	if(clonedName)
+-		free(clonedName);
++		kfree(clonedName);
+ 
+ 	return NULL;
+ }
+-
+diff --git a/yaffs/direct/ydirectenv.h b/yaffs/direct/ydirectenv.h
+index 7860b84..5add3ec 100644
+--- a/yaffs/direct/ydirectenv.h
++++ b/yaffs/direct/ydirectenv.h
+@@ -22,16 +22,13 @@
+ 
+ // Direct interface
+ 
+-#include "stdlib.h"
+-#include "stdio.h"
++#include <rtthread.h>
+ #include "string.h"
++
+ #include "yaffs_osglue.h"
+ #include "yaffs_hweight.h"
+ 
+-#include "assert.h"
+-#define BUG() assert(0)
+-//#define BUG() do { *((int *)0) =1;} while(0)
+-
++#define BUG() RT_ASSERT(0)
+ 
+ #define YCHAR char
+ #define YUCHAR unsigned char
+@@ -47,30 +44,24 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
+         
+ #define YAFFS_PATH_DIVIDERS  "/"
+ 
+-#ifdef NO_inline
+-#define inline
+-#else
+-#define inline __inline__
+-#endif
+-
+-#define kmalloc(x,flags) yaffsfs_malloc(x)
++#define GFP_NOFS  0
++#define kmalloc(x, y) yaffsfs_malloc(x)
+ #define kfree(x)   yaffsfs_free(x)
+ #define vmalloc(x) yaffsfs_malloc(x)
+-#define vfree(x) yaffsfs_free(x)
++#define vfree(x)   yaffsfs_free(x)
++#define printf     rt_kprintf
+ 
+ #define cond_resched()  do {} while(0)
+ 
+ #define yaffs_trace(msk, fmt, ...) do { \
+ 	if(yaffs_trace_mask & (msk)) \
+-		printf("yaffs: " fmt "\n", ##__VA_ARGS__); \
++		rt_kprintf("yaffs: " fmt "\n", ##__VA_ARGS__); \
+ } while(0)
+ 
+ 
+ #define YAFFS_LOSTNFOUND_NAME		"lost+found"
+ #define YAFFS_LOSTNFOUND_PREFIX		"obj"
+ 
+-#include "yaffscfg.h"
+-
+ #define Y_CURRENT_TIME yaffsfs_CurrentTime()
+ #define Y_TIME_CONVERT(x) x
+ 
+@@ -79,8 +70,6 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
+ 
+ #include "yaffs_list.h"
+ 
+-#include "yaffsfs.h"
+-
+ #endif
+ 
+ 
+diff --git a/yaffs/direct/yportenv.h b/yaffs/direct/yportenv.h
+index 939cd3a..f693c16 100644
+--- a/yaffs/direct/yportenv.h
++++ b/yaffs/direct/yportenv.h
+@@ -17,36 +17,146 @@
+ #ifndef __YPORTENV_H__
+ #define __YPORTENV_H__
+ 
++#include <dfs_posix.h>
++
++#define CONFIG_YAFFS_DIRECT
++#define CONFIG_YAFFS_PROVIDE_DEFS
++#define CONFIG_YAFFSFS_PROVIDE_VALUES
++
++#ifdef NO_inline
++	#define inline
++#else
++	#ifdef __CC_ARM  
++	    #define inline   __inline
++	#elif defined (__GNUC__)        		/* GNU GCC Compiler */
++	    #define inline   __inline
++	#else
++		#error "Please set a macro inline with a valid args" 	
++	#endif
++#endif
++
++#if defined(__CC_ARM)
++	#ifdef RT_USING_NEWLIB
++		#error "error: when use armcc, please Don't USE NEWLIB!!!"
++	#endif
++	
++	#ifndef off_t
++	typedef long off_t;
++	#endif
++	
++	#ifndef loff_t
++	typedef unsigned long loff_t;
++	#endif
++	
++	#ifndef dev_t
++	typedef long dev_t;
++	#endif
++	
++	#ifndef mode_t
++	typedef int mode_t;
++	#endif
++
++	/* just like strlen(3), but cap the number of bytes we count */
++	rt_inline size_t strnlen(const char *s, size_t max) {
++		register const char *p;
++		for(p = s; *p && max--; ++p);
++		return(p - s);
++	}
++
++#elif defined (__GNUC__) && !defined(__CC_ARM)
++
++	#ifndef loff_t
++	typedef unsigned long loff_t;
++	#endif
++
++	#ifndef dev_t
++	typedef long dev_t;
++	#endif
++#endif
+ 
+ /* Definition of types */
+ typedef unsigned char u8;
+ typedef unsigned short u16;
+ typedef unsigned u32;
+-
+-
+-#ifndef WIN32
+-#include <sys/stat.h>
+-#endif
+-
++ 
++#ifndef S_ISDIR
++	#ifndef _DEV_T_DEFINED
++	typedef unsigned int _dev_t;            /* device code */
++	#if     !__STDC__
++	/* Non-ANSI name for compatibility */
++	typedef unsigned int dev_t;
++	#endif
++	 
++	#define _DEV_T_DEFINED
++	#endif
++
++	#define __S_IFMT 0170000 /* These bits determine file type.  */
++	/* File types.  */
++	#define __S_IFDIR 0040000 /* Directory.  */
++	#define __S_IFCHR 0020000 /* Character device.  */
++	#define __S_IFBLK 0060000 /* Block device.  */
++	#define __S_IFREG 0100000 /* Regular file.  */
++	#define __S_IFIFO 0010000 /* FIFO.  */
++	#define __S_IFLNK 0120000 /* Symbolic link.  */
++	#define __S_IFSOCK 0140000 /* Socket.  */
++	 
++	/* Protection bits.  */
++	#define __S_ISUID 04000 /* Set user ID on execution.  */
++	#define __S_ISGID 02000 /* Set group ID on execution.  */
++	#define __S_ISVTX 01000 /* Save swapped text after use (sticky).  */
++	#define __S_IREAD 0400 /* Read by owner.  */
++	#define __S_IWRITE 0200 /* Write by owner.  */
++	#define __S_IEXEC 0100 /* Execute by owner.  */
++	#define __S_ISTYPE(mode, mask) (((mode) & __S_IFMT) == (mask))
++
++	#define S_ISDIR(mode)  __S_ISTYPE((mode), __S_IFDIR)
++	#define S_ISCHR(mode)  __S_ISTYPE((mode), __S_IFCHR)
++	#define S_ISBLK(mode)  __S_ISTYPE((mode), __S_IFBLK)
++	#define S_ISREG(mode)  __S_ISTYPE((mode), __S_IFREG)
++	#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)
++	#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFSOCK)
++	#define S_IRUSR __S_IREAD // Read by owner.  
++	#define S_IWUSR __S_IWRITE // Write by owner. 
++	#define S_IXUSR __S_IEXEC // Execute by owner. 
++	#define S_IREAD S_IRUSR
++	#define S_IWRITE S_IWUSR
++	#define S_IEXEC S_IXUSR
++	#define S_IFDIR __S_IFDIR
++#endif 
+ 
+ #ifdef CONFIG_YAFFS_PROVIDE_DEFS
+ /* File types */
+ 
++#ifndef DT_UNKNOWN
++	#define DT_UNKNOWN	0
++#endif
++#ifndef	DT_FIFO
++	#define DT_FIFO		1
++#endif
+ 
+-#define DT_UNKNOWN	0
+-#define DT_FIFO		1
+-#define DT_CHR		2
+-#define DT_DIR		4
+-#define DT_BLK		6
+-#define DT_REG		8
+-#define DT_LNK		10
+-#define DT_SOCK		12
+-#define DT_WHT		14
+-
++#ifndef	DT_CHR
++	#define DT_CHR		2
++#endif
+ 
+-#ifndef WIN32
+-#include <sys/stat.h>
++#ifndef	DT_DIR
++	#define DT_DIR		4
++#endif
++#ifndef	DT_BLK
++	#define DT_BLK		6
++#endif
++#ifndef	DT_REG
++	#define DT_REG		8
+ #endif
++#ifndef	DT_LNK
++	#define DT_LNK		10
++#endif
++#ifndef	DT_SOCK
++	#define DT_SOCK		12
++#endif
++#ifndef	 DT_WHT
++	#define DT_WHT		14
++#endif
++
+ 
+ /*
+  * Attribute flags.
+@@ -75,7 +185,6 @@ struct iattr {
+ #endif
+ 
+ 
+-
+ #if defined CONFIG_YAFFS_WINCE
+ 
+ #include "ywinceenv.h"
+@@ -267,9 +376,17 @@ struct iattr {
+ #endif
+ 
+ #else
+-#include <errno.h>
+-#include <sys/stat.h>
+-#include <fcntl.h>
++//#include <errno.h>
++//#include <sys/stat.h>
++//#include <fcntl.h>
++#ifndef XATTR_CREATE
++#define XATTR_CREATE 1
++#endif
++
++#ifndef XATTR_REPLACE
++#define XATTR_REPLACE 2
++#endif
++
+ #endif
+ 
+ #endif
+diff --git a/yaffs_nandcfg.c b/yaffs_nandcfg.c
+new file mode 100644
+index 0000000..4720aa2
+--- /dev/null
++++ b/yaffs_nandcfg.c
+@@ -0,0 +1,64 @@
++#include <rtthread.h>
#include <rtdevice.h>
#include <dfs_fs.h>
#include <dfs_def.h>
++
#include "yaffsfs.h"
#include "yaffs_nandif.h"
#include "yaffs_trace.h"

/*
 * RT-Thread Device Interface for yaffs
 */
static int nand_init(struct yaffs_dev *dev)
{
	return YAFFS_OK;
}

static int nand_deinit(struct yaffs_dev *dev)
{
	return YAFFS_OK;
}

/* if block is good, return YAFFS_OK, else return YAFFS_FAIL */
static int nand_checkblock(struct yaffs_dev *dev, unsigned block)
{
	rt_err_t res;
	res = rt_mtd_nand_check_block(RT_MTD_NAND_DEVICE(dev->os_context), block);
	return res == RT_EOK ? YAFFS_OK : YAFFS_FAIL;
}
static int nand_markbadblk(struct yaffs_dev *dev, unsigned block)
{
	rt_err_t res;
	res = rt_mtd_nand_mark_badblock(RT_MTD_NAND_DEVICE(dev->os_context), block);
	return res == RT_EOK ? YAFFS_OK : YAFFS_FAIL;
}

static int nand_eraseblock(struct yaffs_dev *dev, unsigned block)
{
	int res;
	res = rt_mtd_nand_erase_block(RT_MTD_NAND_DEVICE(dev->os_context), block);
	return 	res == RT_EOK ? YAFFS_OK : YAFFS_FAIL;
}

static int nand_readpage(
	struct yaffs_dev *dev,
    unsigned page,
    unsigned char *data, unsigned data_len, /* page data */
    unsigned char *spare, unsigned spare_len,/* page spare */
    int *ecc_status)
{
	int res;
	unsigned char spare_buf[64];

	res = rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->os_context),
	                   	   page, data, data_len, spare_buf, spare_len + 5);
	rt_memcpy(spare, spare_buf + 5, spare_len);
	if (res == 0)
		*ecc_status = 0;
	else if (res == -1)
		*ecc_status = 1;
	else
		*ecc_status = -1;

	return YAFFS_OK;
}

static int nand_writepage(
	struct yaffs_dev *dev,
	unsigned page,
	const unsigned char *data, unsigned data_len, /* page data */
    const unsigned char *spare, unsigned spare_len) /* page spare */
{
	int res;
	unsigned char spare_buf[64]; //not use malloc, this can be faster
	rt_memset(spare_buf, 0xFF, sizeof(spare_buf));
	rt_memcpy(spare_buf+5, spare, spare_len);

	res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->os_context),
						   page, data, data_len, spare_buf, spare_len + 5);
	if (res != RT_EOK)
		goto __error;

	return YAFFS_OK;

__error:
	return YAFFS_FAIL;
}
++
++
++/*

++ * yaffs2 configuration

++ */

++#define CONFIG_YAFFS_ECC_MODE     1 //1 use ecc, 0 no ecc

++#define CONFIG_YAFFS_INBAND_TAGS  0 //1 use in band tags, 0-no in band tags

++#define CONFIG_YAFFS_USE_YAFFS2   1 //1 yaffs2, 0-yaffs1

++

++void yaffs_config(ynandif_Geometry * g, struct rt_mtd_nand_device * dev)

++{

++	rt_memset(g,0,sizeof(ynandif_Geometry));

++

++	g->start_block   = dev->block_start;

++	g->end_block     = dev->block_end;

++	g->dataSize      = dev->page_size;

++	g->spareSize     = dev->oob_size;

++	g->pagesPerBlock = dev->block_size / dev->page_size;

++

++	g->hasECC        = CONFIG_YAFFS_ECC_MODE;

++	g->inband_tags   = CONFIG_YAFFS_INBAND_TAGS;

++	g->useYaffs2     = CONFIG_YAFFS_USE_YAFFS2;

++

++	g->privateData   = dev;//will be copy to dev->os_context.

++

++	g->initialise = nand_init;

++	g->deinitialise = nand_deinit;

++	g->readChunk = nand_readpage;

++	g->writeChunk = nand_writepage;

++	g->eraseBlock = nand_eraseblock;

++	g->checkBlockOk = nand_checkblock;

++	g->markBlockBad = nand_markbadblk;

++}

++

++static struct yaffs_dev *ynand_CreatePart(const YCHAR *name, ynandif_Geometry * g)

++{

++	return yaffs_add_dev_from_geometry(name, g);

++}

++

++/* configuration for yaffs's log */

++unsigned yaffs_trace_mask =

++

++	YAFFS_TRACE_SCAN |

++	YAFFS_TRACE_GC |

++	YAFFS_TRACE_ERASE |

++	YAFFS_TRACE_ERROR |

++	YAFFS_TRACE_TRACING |

++	YAFFS_TRACE_ALLOCATE |

++	YAFFS_TRACE_BAD_BLOCKS |

++	YAFFS_TRACE_VERIFY |

++

++	0;

++

++int yaffs_start(const char * mount_point, ynandif_Geometry * g)

++{

++	// Stuff to configure YAFFS

++	// Stuff to initialise anything special (eg lock semaphore).

++	yaffsfs_OSInitialisation();

++	ynand_CreatePart(mount_point, g);

++

++	return 0;

++}
+diff --git a/yaffs_osglue.c b/yaffs_osglue.c
+new file mode 100644
+index 0000000..2c34f99
+--- /dev/null
++++ b/yaffs_osglue.c
+@@ -0,0 +1,118 @@
++/*
++ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
++ *
++ * Copyright (C) 2002-2011 Aleph One Ltd.
++ *   for Toby Churchill Ltd and Brightstar Engineering
++ *
++ * Created by Charles Manning <[email protected]>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++
++
++#include "yaffscfg.h"
++#include "yaffs_guts.h"
++#include "yaffsfs.h"
++#include "yaffs_trace.h"
++#include <rtthread.h>
++
++//#include <errno.h>
++
++
++static int yaffsfs_lastError;
++
++void yaffsfs_SetError(int err)
++{
++	//Do whatever to set error
++	yaffsfs_lastError = err;
++}
++
++int yaffsfs_GetLastError(void)
++{
++	return yaffsfs_lastError;
++}
++
++
++#ifdef CONFIG_YAFFS_USE_PTHREADS
++#include <pthread.h>
++static pthread_mutex_t mutex1;
++
++
++void yaffsfs_Lock(void)
++{
++	pthread_mutex_lock( &mutex1 );
++}
++
++void yaffsfs_Unlock(void)
++{
++	pthread_mutex_unlock( &mutex1 );
++}
++
++void yaffsfs_LockInit(void)
++{
++	pthread_mutex_init( &mutex1, NULL);
++}
++
++#else
++
++static rt_mutex_t mutex = RT_NULL;
++static rt_sem_t sem = RT_NULL;
++void yaffsfs_Lock(void)
++{
++	rt_mutex_take(mutex, RT_WAITING_FOREVER);
++}
++
++void yaffsfs_Unlock(void)
++{
++	rt_mutex_release(mutex);
++}
++
++void yaffsfs_LockInit(void)
++{
++	mutex = rt_mutex_create("mutex", RT_IPC_FLAG_FIFO);
++    if (mutex == RT_NULL)
++    {
++		yaffs_trace(YAFFS_TRACE_ERROR,
++			"**>> yaffs error :yaffs_LockInit can't get a mutex!");
++    }
++
++}
++#endif
++
++u32 yaffsfs_CurrentTime(void)
++{
++	return 0;
++}
++
++
++static int yaffs_kill_alloc = 0;
++static size_t total_malloced = 0;
++static size_t malloc_limit = 0 & 6000000;
++
++void *yaffsfs_malloc(size_t size)
++{
++	void * this;
++	if(yaffs_kill_alloc)
++		return NULL;
++	if(malloc_limit && malloc_limit <(total_malloced + size) )
++		return NULL;
++
++	this = rt_malloc(size);
++	if(this)
++		total_malloced += size;
++	return this;
++}
++
++void yaffsfs_free(void *ptr)
++{
++	rt_free(ptr);
++}
++
++void yaffsfs_OSInitialisation(void)
++{
++	yaffsfs_LockInit();
++}
++
++