From: Charles Manning <cdhmanning@gmail.com>
Date: Tue, 2 Oct 2012 02:41:32 +0000 (+1300)
Subject: Merge branch 'driver-refactoring' into new-driver-refactoring
X-Git-Tag: aleph1-release~73
X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=commitdiff_plain;h=54721f22512e7c859c4c4a4ae7e5374ecf7fb570;hp=c08faae4258b29a794ad55ca160c5a247145c838

Merge branch 'driver-refactoring' into new-driver-refactoring
---

diff --git a/direct/test-framework/basic-tests/dtest.c b/direct/test-framework/basic-tests/dtest.c
index 153d274..3cd13ab 100644
--- a/direct/test-framework/basic-tests/dtest.c
+++ b/direct/test-framework/basic-tests/dtest.c
@@ -3042,6 +3042,70 @@ void large_file_test(const char *mountpt)
 }
 
 
+int  mk_dir(const char *mp, const char *name)
+{
+	char full_name[100];
+
+	sprintf(full_name, "%s/%s", mp, name);
+
+	return yaffs_mkdir(full_name, S_IREAD| S_IWRITE);
+}
+
+int  mk_file(const char *mp, const char *name)
+{
+	char full_name[100];
+	int h;
+
+	sprintf(full_name, "%s/%s", mp, name);
+
+	h = yaffs_open(full_name, O_RDWR | O_CREAT | O_TRUNC, S_IREAD| S_IWRITE);
+
+	yaffs_write(h, name, strlen(name));
+
+	yaffs_close(h);
+	return 0;
+}
+
+void xx_test(const char *mountpt)
+{
+	char xx_buffer[1000];
+
+	yaffs_start_up();
+
+	yaffs_format(mountpt,0,0,0);
+
+	yaffs_mount(mountpt);
+	printf("mounted\n");
+	dumpDir(mountpt);
+
+	printf("create files\n");
+
+	mk_dir(mountpt, "foo");
+	mk_file(mountpt, "foo/f1");
+	mk_file(mountpt, "foo/f2");
+	mk_file(mountpt, "foo/f3");
+	mk_file(mountpt, "foo/f4");
+	dump_directory_tree(mountpt);
+
+	printf("unmount and remount\n");
+
+	/* Unmount/remount */
+	yaffs_unmount(mountpt);
+	yaffs_mount(mountpt);
+	dump_directory_tree(mountpt);
+}
+
+void yy_test(const char *mountpt)
+{
+	char xx_buffer[1000];
+
+	yaffs_start_up();
+
+	yaffs_mount(mountpt);
+	dump_directory_tree(mountpt);
+}
+
+
 void readdir_test(const char *mountpt)
 {
 	char xx_buffer[1000];
@@ -3081,6 +3145,32 @@ void readdir_test(const char *mountpt)
 
 }
 
+void format_test(const char *mountpt)
+{
+	int ret;
+
+	yaffs_start_up();
+
+	ret = yaffs_format(mountpt, 0, 0, 0);
+	printf("yaffs_format(...,0, 0, 0) of unmounted returned %d\n", ret);
+
+	yaffs_mount(mountpt);
+
+	ret = yaffs_format(mountpt, 0, 0, 0);
+	printf("yaffs_format(...,0, 0, 0) of mounted returned %d\n", ret);
+
+	ret = yaffs_format(mountpt, 1, 0, 0);
+	printf("yaffs_format(...,1, 0, 0) of mounted returned %d\n", ret);
+
+	ret = yaffs_mount(mountpt);
+	printf("mount should return 0 returned %d\n", ret);
+
+	ret = yaffs_format(mountpt, 1, 0, 1);
+	printf("yaffs_format(...,1, 0, 1) of mounted returned %d\n", ret);
+
+	ret = yaffs_mount(mountpt);
+	printf("mount should return -1 returned %d\n", ret);
+}
 
 int random_seed;
 int simulate_power_failure;
@@ -3149,7 +3239,10 @@ int main(int argc, char *argv[])
 	 // link_follow_test("/yaffs2");
 	 //basic_utime_test("/yaffs2");
 
-	max_files_test("/yaffs2");
+
+	//format_test("/yaffs2");
+
+	//max_files_test("/yaffs2");
 
 	 //start_twice("/yaffs2");
 
@@ -3159,6 +3252,9 @@ int main(int argc, char *argv[])
 	 //basic_utime_test("/yaffs2");
 	 //case_insensitive_test("/yaffs2");
 
+	 yy_test("/yaffs2");
+
+
 	 return 0;
 
 }
diff --git a/direct/u-boot/common/cmd_yaffs2.c b/direct/u-boot/common/cmd_yaffs2.c
index d43a9d4..23cf000 100644
--- a/direct/u-boot/common/cmd_yaffs2.c
+++ b/direct/u-boot/common/cmd_yaffs2.c
@@ -17,6 +17,7 @@
 
 #include <config.h>
 #include <command.h>
+#include "../fs/yaffs2/yaffs_uboot_glue.h"
 
 #ifdef YAFFS2_DEBUG
 #define PRINTF(fmt, args...) printf(fmt, ##args)
@@ -24,41 +25,20 @@
 #define PRINTF(fmt, args...) do { } while (0)
 #endif
 
-extern void cmd_yaffs_dev_ls(void);
-extern void cmd_yaffs_tracemask(unsigned set, unsigned mask);
-extern void cmd_yaffs_devconfig(char *mp, int flash_dev,
-				int start_block, int end_block);
-extern void cmd_yaffs_mount(char *mp);
-extern void cmd_yaffs_umount(char *mp);
-extern void cmd_yaffs_read_file(char *fn);
-extern void cmd_yaffs_write_file(char *fn, char bval, int sizeOfFile);
-extern void cmd_yaffs_ls(const char *mountpt, int longlist);
-extern void cmd_yaffs_mwrite_file(char *fn, char *addr, int size);
-extern void cmd_yaffs_mread_file(char *fn, char *addr);
-extern void cmd_yaffs_mkdir(const char *dir);
-extern void cmd_yaffs_rmdir(const char *dir);
-extern void cmd_yaffs_rm(const char *path);
-extern void cmd_yaffs_mv(const char *oldPath, const char *newPath);
-
-extern int yaffs_dump_dev(const char *path);
 
 /* ytrace - show/set yaffs trace mask */
 int do_ytrace(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 {
 	if (argc > 1)
-		cmd_yaffs_tracemask(1, simple_strtol(argv[1], NULL, 16));
+		return cmd_yaffs_tracemask(1, simple_strtol(argv[1], NULL, 16));
 	else
-		cmd_yaffs_tracemask(0, 0);
-
-	return 0;
+		return cmd_yaffs_tracemask(0, 0);
 }
 
 /* ydevls - lists yaffs mount points. */
 int do_ydevls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 {
-	cmd_yaffs_dev_ls();
-
-	return 0;
+	return cmd_yaffs_dev_ls();
 }
 
 /* ydevconfig mount_pt mtd_dev_num start_block end_block */
@@ -80,9 +60,7 @@ int do_ydevconfig(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	start_block = simple_strtol(argv[3], NULL, 16);
 	end_block = simple_strtol(argv[4], NULL, 16);
 
-	cmd_yaffs_devconfig(mtpoint, mtd_dev, start_block, end_block);
-
-	return 0;
+	return cmd_yaffs_devconfig(mtpoint, mtd_dev, start_block, end_block);
 }
 
 int do_ymount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -97,9 +75,7 @@ int do_ymount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	mtpoint = argv[1];
 	printf("Mounting yaffs2 mount point %s\n", mtpoint);
 
-	cmd_yaffs_mount(mtpoint);
-
-	return 0;
+	return cmd_yaffs_mount(mtpoint);
 }
 
 int do_yumount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -113,9 +89,7 @@ int do_yumount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 
 	mtpoint = argv[1];
 	printf("Unmounting yaffs2 mount point %s\n", mtpoint);
-	cmd_yaffs_umount(mtpoint);
-
-	return 0;
+	return cmd_yaffs_umount(mtpoint);
 }
 
 int do_yls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -129,9 +103,30 @@ int do_yls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 
 	dirname = argv[argc - 1];
 
-	cmd_yaffs_ls(dirname, (argc > 2) ? 1 : 0);
+	return cmd_yaffs_ls(dirname, (argc > 2) ? 1 : 0);
+}
 
-	return 0;
+static int ycheck_option_valid(const char *str)
+{
+	return strcmp(str,"DIR") == 0 || strcmp(str,"REG") == 0;
+}
+
+int do_ycheck(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+{
+	const char *dirname;
+	const char *str = "ANY";
+
+	if (argc < 2 || argc > 3 ||
+	(argc == 3 && ! ycheck_option_valid(argv[2]))) {
+		printf("Bad arguments: ycheck name [DIR|REG]");
+		return -1;
+	}
+
+	dirname = argv[1];
+	if(argc>2)
+		str = argv[2];
+
+	return cmd_yaffs_check(dirname, str);
 }
 
 int do_yrd(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -147,10 +142,7 @@ int do_yrd(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 
 	printf("Reading file %s ", filename);
 
-	cmd_yaffs_read_file(filename);
-
-	printf("done\n");
-	return 0;
+	return cmd_yaffs_read_file(filename);
 }
 
 int do_ywr(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -171,10 +163,7 @@ int do_ywr(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	printf("Writing value (%lx) %lx times to %s... ", value, numValues,
 	       filename);
 
-	cmd_yaffs_write_file(filename, value, numValues);
-
-	printf("done\n");
-	return 0;
+	return cmd_yaffs_write_file(filename, value, numValues);
 }
 
 int do_yrdm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -190,9 +179,7 @@ int do_yrdm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	filename = argv[1];
 	addr = simple_strtoul(argv[2], NULL, 16);
 
-	cmd_yaffs_mread_file(filename, (char *)addr);
-
-	return 0;
+	return cmd_yaffs_mread_file(filename, (char *)addr);
 }
 
 int do_ywrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -210,9 +197,7 @@ int do_ywrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	addr = simple_strtoul(argv[2], NULL, 16);
 	size = simple_strtoul(argv[3], NULL, 16);
 
-	cmd_yaffs_mwrite_file(filename, (char *)addr, size);
-
-	return 0;
+	return cmd_yaffs_mwrite_file(filename, (char *)addr, size);
 }
 
 int do_ymkdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -225,9 +210,7 @@ int do_ymkdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	}
 
 	dirname = argv[1];
-	cmd_yaffs_mkdir(dirname);
-
-	return 0;
+	return cmd_yaffs_mkdir(dirname);
 }
 
 int do_yrmdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -240,9 +223,7 @@ int do_yrmdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	}
 
 	dirname = argv[1];
-	cmd_yaffs_rmdir(dirname);
-
-	return 0;
+	return cmd_yaffs_rmdir(dirname);
 }
 
 int do_yrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -256,9 +237,7 @@ int do_yrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 
 	name = argv[1];
 
-	cmd_yaffs_rm(name);
-
-	return 0;
+	return cmd_yaffs_rm(name);
 }
 
 int do_ymv(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
@@ -274,9 +253,7 @@ int do_ymv(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 	oldPath = argv[1];
 	newPath = argv[2];
 
-	cmd_yaffs_mv(newPath, oldPath);
-
-	return 0;
+	return cmd_yaffs_mv(newPath, oldPath);
 }
 
 U_BOOT_CMD(ytrace, 2, 0, do_ytrace,
@@ -298,6 +275,9 @@ U_BOOT_CMD(yumount, 2, 0, do_yumount,
 
 U_BOOT_CMD(yls, 3, 0, do_yls, "yaffs ls", "yls [-l] dirname");
 
+U_BOOT_CMD(ycheck, 3, 0, do_ycheck,
+	   "ycheck name [DIR|REG]", "checks if the named object exists");
+
 U_BOOT_CMD(yrd, 2, 0, do_yrd,
 	   "read file from yaffs", "yrd path   read file from yaffs");
 
diff --git a/direct/u-boot/fs/yaffs2/Makefile b/direct/u-boot/fs/yaffs2/Makefile
index d2ae2bf..f45c19d 100644
--- a/direct/u-boot/fs/yaffs2/Makefile
+++ b/direct/u-boot/fs/yaffs2/Makefile
@@ -35,6 +35,11 @@ YCFLAGS =  -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM
 YCFLAGS += -DCONFIG_YAFFS_YAFFS2 -DNO_Y_INLINE
 YCFLAGS += -DCONFIG_YAFFS_PROVIDE_DEFS -DCONFIG_YAFFSFS_PROVIDE_VALUES
 
+#
+# To enable 32-bit loff_t uncomment the following 
+#
+YCFLAGS += -DY_LOFF_T=int
+
 CFLAGS += $(YCFLAGS)
 CPPFLAGS +=  $(YCFLAGS)
 
diff --git a/direct/u-boot/fs/yaffs2/yaffs_mtdif.c b/direct/u-boot/fs/yaffs2/yaffs_mtdif.c
index db49052..b7ec909 100644
--- a/direct/u-boot/fs/yaffs2/yaffs_mtdif.c
+++ b/direct/u-boot/fs/yaffs2/yaffs_mtdif.c
@@ -66,7 +66,7 @@ int nandmtd_WriteChunkToNAND(struct yaffs_dev *dev, int chunkInNAND,
 	struct mtd_oob_ops ops;
 	size_t dummy;
 	int retval = 0;
-	loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->param.total_bytes_per_chunk;
 	u8 spareAsBytes[8]; /* OOB */
 
 	if (data && !spare)
@@ -102,7 +102,7 @@ int nandmtd_ReadChunkFromNAND(struct yaffs_dev *dev, int chunkInNAND, u8 *data,
 	size_t dummy;
 	int retval = 0;
 
-	loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk;
+	loff_t addr = ((loff_t) chunkInNAND) * dev->param.total_bytes_per_chunk;
 	u8 spareAsBytes[8]; /* OOB */
 
 	if (data && !spare)
@@ -135,7 +135,7 @@ int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context);
 	__u32 addr =
-	    ((loff_t) blockNumber) * dev->data_bytes_per_chunk
+	    ((loff_t) blockNumber) * dev->param.total_bytes_per_chunk
 		* dev->param.chunks_per_block;
 	struct erase_info ei;
 	int retval = 0;
diff --git a/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c b/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c
index e113e40..f7ac21c 100644
--- a/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c
+++ b/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c
@@ -28,6 +28,8 @@
 #include "yaffs_packedtags2.h"
 #include "yaffs_mtdif.h"
 #include "yaffs_mtdif2.h"
+#include "yaffs_uboot_glue.h"
+
 #if 0
 #include <errno.h>
 #else
@@ -142,12 +144,13 @@ static const char *yaffs_error_str(void)
 
 extern nand_info_t nand_info[];
 
-void cmd_yaffs_tracemask(unsigned set, unsigned mask)
+int cmd_yaffs_tracemask(unsigned set, unsigned mask)
 {
 	if (set)
 		yaffs_trace_mask = mask;
 
 	printf("yaffs trace mask: %08x\n", yaffs_trace_mask);
+	return 0;
 }
 
 static int yaffs_regions_overlap(int a, int b, int x, int y)
@@ -158,7 +161,7 @@ static int yaffs_regions_overlap(int a, int b, int x, int y)
 		(x <= b && b <= y);
 }
 
-void cmd_yaffs_devconfig(char *_mp, int flash_dev,
+int cmd_yaffs_devconfig(char *_mp, int flash_dev,
 			int start_block, int end_block)
 {
 	struct mtd_info *mtd = NULL;
@@ -240,14 +243,15 @@ void cmd_yaffs_devconfig(char *_mp, int flash_dev,
 	printf("Configures yaffs mount %s: dev %d start block %d, end block %d %s\n",
 		mp, flash_dev, start_block, end_block,
 		dev->param.inband_tags ? "using inband tags" : "");
-	return;
+	return 0;
 
 err:
 	free(dev);
 	free(mp);
+	return -1;
 }
 
-void cmd_yaffs_dev_ls(void)
+int cmd_yaffs_dev_ls(void)
 {
 	struct yaffs_dev *dev;
 	int flash_dev;
@@ -258,7 +262,7 @@ void cmd_yaffs_dev_ls(void)
 	while (1) {
 		dev = yaffs_next_dev();
 		if (!dev)
-			return;
+			break;
 		flash_dev =
 			((unsigned) dev->driver_context - (unsigned) nand_info)/
 				sizeof(nand_info[0]);
@@ -274,12 +278,15 @@ void cmd_yaffs_dev_ls(void)
 			printf("free 0x%x\n", free_space);
 
 	}
+
+	return 0;
 }
 
-void make_a_file(char *yaffsName, char bval, int sizeOfFile)
+int make_a_file(char *yaffsName, char bval, int sizeOfFile)
 {
 	int outh;
 	int i;
+	int written;
 	unsigned char buffer[100];
 
 	outh = yaffs_open(yaffsName,
@@ -287,26 +294,28 @@ void make_a_file(char *yaffsName, char bval, int sizeOfFile)
 				S_IREAD | S_IWRITE);
 	if (outh < 0) {
 		printf("Error opening file: %d. %s\n", outh, yaffs_error_str());
-		return;
+		return -1;
 	}
 
 	memset(buffer, bval, 100);
 
-	do {
-		i = sizeOfFile;
+	written = 0;
+	while (written < sizeOfFile) {
+		i = sizeOfFile - written;
 		if (i > 100)
 			i = 100;
-		sizeOfFile -= i;
-
-		yaffs_write(outh, buffer, i);
-
-	} while (sizeOfFile > 0);
 
+		if (yaffs_write(outh, buffer, i) != i)
+			break;
+		written += i;
+	}
 
 	yaffs_close(outh);
+
+	return (written == sizeOfFile) ? 0 : -1;
 }
 
-void read_a_file(char *fn)
+int read_a_file(char *fn)
 {
 	int h;
 	int i = 0;
@@ -315,7 +324,7 @@ void read_a_file(char *fn)
 	h = yaffs_open(fn, O_RDWR, 0);
 	if (h < 0) {
 		printf("File not found\n");
-		return;
+		return -1;
 	}
 
 	while (yaffs_read(h, &b, 1) > 0) {
@@ -328,40 +337,49 @@ void read_a_file(char *fn)
 	}
 	printf("\n");
 	yaffs_close(h);
+
+	return 0;
 }
 
-void cmd_yaffs_mount(char *mp)
+int cmd_yaffs_mount(char *mp)
 {
 	int retval = yaffs_mount(mp);
 	if (retval < 0)
 		printf("Error mounting %s, return value: %d, %s\n", mp,
 			yaffsfs_GetError(), yaffs_error_str());
+	return retval;
 }
 
 
-void cmd_yaffs_umount(char *mp)
+int cmd_yaffs_umount(char *mp)
 {
-	if (yaffs_unmount(mp) == -1)
+	int retval = yaffs_unmount(mp);
+
+	if (retval < 0)
 		printf("Error umounting %s, return value: %d, %s\n", mp,
 			yaffsfs_GetError(), yaffs_error_str());
+	return retval;
 }
 
-void cmd_yaffs_write_file(char *yaffsName, char bval, int sizeOfFile)
+int cmd_yaffs_write_file(char *yaffsName, char bval, int sizeOfFile)
 {
-	make_a_file(yaffsName, bval, sizeOfFile);
+	return make_a_file(yaffsName, bval, sizeOfFile);
 }
 
 
-void cmd_yaffs_read_file(char *fn)
+int cmd_yaffs_read_file(char *fn)
 {
-	read_a_file(fn);
+	return read_a_file(fn);
 }
 
 
-void cmd_yaffs_mread_file(char *fn, char *addr)
+int cmd_yaffs_mread_file(char *fn, char *addr)
 {
 	int h;
+	int retval = 0;
 	struct yaffs_stat s;
+	int read_size;
+	char buf[16];
 
 	yaffs_stat(fn, &s);
 
@@ -369,31 +387,47 @@ void cmd_yaffs_mread_file(char *fn, char *addr)
 	h = yaffs_open(fn, O_RDWR, 0);
 	if (h < 0) {
 		printf("File not found\n");
-		return;
+		retval = -1;
+		read_size = 0;
+	} else {
+		read_size = (int) s.st_size;
+		yaffs_read(h, addr, read_size);
+		printf("\t[DONE]\n");
+
+		yaffs_close(h);
 	}
+	sprintf(buf,"%x", read_size);
+	setenv("filesize", buf);
 
-	yaffs_read(h, addr, (int)s.st_size);
-	printf("\t[DONE]\n");
-
-	yaffs_close(h);
+	return retval;
 }
 
 
-void cmd_yaffs_mwrite_file(char *fn, char *addr, int size)
+int cmd_yaffs_mwrite_file(char *fn, char *addr, int size)
 {
 	int outh;
+	int wrote;
 
 	outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
-	if (outh < 0)
+	if (outh < 0) {
 		printf("Error opening file: %d, %s\n", outh, yaffs_error_str());
+		return -1;
+	}
 
-	yaffs_write(outh, addr, size);
-
+	wrote = yaffs_write(outh, addr, size);
 	yaffs_close(outh);
+
+	if(wrote != size) {
+		printf("only wrote %d (0x%x) bytes\n", wrote, wrote);
+		return -1;
+	}
+	return 0;
+
+
 }
 
 
-void cmd_yaffs_ls(const char *mountpt, int longlist)
+int cmd_yaffs_ls(const char *mountpt, int longlist)
 {
 	int i;
 	yaffs_DIR *d;
@@ -405,7 +439,7 @@ void cmd_yaffs_ls(const char *mountpt, int longlist)
 
 	if (!d) {
 		printf("opendir failed, %s\n", yaffs_error_str());
-		return;
+		return -1;
 	}
 
 	for (i = 0; (de = yaffs_readdir(d)) != NULL; i++) {
@@ -424,41 +458,87 @@ void cmd_yaffs_ls(const char *mountpt, int longlist)
 	}
 
 	yaffs_closedir(d);
+
+	return 0;
 }
 
+int cmd_yaffs_check(const char *fname, const char *type)
+{
+	int retval = 0;
+	int ret;
+	struct yaffs_stat stat;
+
+	ret = yaffs_stat(fname, &stat);
+	if (ret < 0) {
+		printf("%s not found\n", fname);
+		return -1;
+	}
+
+	printf("%s is a %s\n", fname, yaffs_file_type_str(&stat));
+
+	if (strcmp(type, "REG") == 0 &&
+	    (stat.st_mode & S_IFMT) != S_IFREG)
+		retval = -1;
 
-void cmd_yaffs_mkdir(const char *dir)
+	if (strcmp(type, "DIR") == 0 &&
+	    (stat.st_mode & S_IFMT) != S_IFDIR)
+		retval = -1;
+
+	if (retval == 0)
+		printf("check ok\n");
+	else
+		printf("check failed\n");
+
+	return retval;
+}
+
+
+int cmd_yaffs_mkdir(const char *dir)
 {
 	int retval = yaffs_mkdir(dir, 0);
 
-	if (retval < 0)
+	if (retval < 0) {
 		printf("yaffs_mkdir returning error: %d, %s\n",
 			retval, yaffs_error_str());
+		return -1;
+	}
+	return 0;
 }
 
-void cmd_yaffs_rmdir(const char *dir)
+int cmd_yaffs_rmdir(const char *dir)
 {
 	int retval = yaffs_rmdir(dir);
 
-	if (retval < 0)
+	if (retval < 0) {
 		printf("yaffs_rmdir returning error: %d, %s\n",
 			retval, yaffs_error_str());
+		return -1;
+	}
+	return 0;
 }
 
-void cmd_yaffs_rm(const char *path)
+int cmd_yaffs_rm(const char *path)
 {
 	int retval = yaffs_unlink(path);
 
-	if (retval < 0)
+	if (retval < 0) {
 		printf("yaffs_unlink returning error: %d, %s\n",
 			retval, yaffs_error_str());
+		return -1;
+	}
+
+	return 0;
 }
 
-void cmd_yaffs_mv(const char *oldPath, const char *newPath)
+int cmd_yaffs_mv(const char *oldPath, const char *newPath)
 {
 	int retval = yaffs_rename(newPath, oldPath);
 
-	if (retval < 0)
+	if (retval < 0) {
 		printf("yaffs_unlink returning error: %d, %s\n",
 			retval, yaffs_error_str());
+		return -1;
+	}
+
+	return 0;
 }
diff --git a/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.h b/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.h
new file mode 100644
index 0000000..d3ae162
--- /dev/null
+++ b/direct/u-boot/fs/yaffs2/yaffs_uboot_glue.h
@@ -0,0 +1,24 @@
+
+#ifndef __YAFFS_UBOOT_GLUE_H__
+#define __YAFFS_UBOOT_GLUE_H__
+
+
+int cmd_yaffs_dev_ls(void);
+int cmd_yaffs_tracemask(unsigned set, unsigned mask);
+int cmd_yaffs_devconfig(char *mp, int flash_dev,
+				int start_block, int end_block);
+int cmd_yaffs_mount(char *mp);
+int cmd_yaffs_umount(char *mp);
+int cmd_yaffs_read_file(char *fn);
+int cmd_yaffs_write_file(char *fn, char bval, int sizeOfFile);
+int cmd_yaffs_ls(const char *mountpt, int longlist);
+int cmd_yaffs_check(const char *fn, const char *type);
+int cmd_yaffs_mwrite_file(char *fn, char *addr, int size);
+int cmd_yaffs_mread_file(char *fn, char *addr);
+int cmd_yaffs_mkdir(const char *dir);
+int cmd_yaffs_rmdir(const char *dir);
+int cmd_yaffs_rm(const char *path);
+int cmd_yaffs_mv(const char *oldPath, const char *newPath);
+
+int yaffs_dump_dev(const char *path);
+#endif
diff --git a/direct/u-boot/patch-u-boot.sh b/direct/u-boot/patch-u-boot.sh
index 8caa2e8..fc17552 100755
--- a/direct/u-boot/patch-u-boot.sh
+++ b/direct/u-boot/patch-u-boot.sh
@@ -17,7 +17,7 @@
 #
 #  Inspired yaffs kernel patching script
 
-set -e -x
+#set -e -x
 
 UBOOTDIR=$1
 
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index def672d..7ee486a 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -2661,6 +2661,67 @@ int yaffs_unmount(const YCHAR *path)
 	return yaffs_unmount2(path, 0);
 }
 
+int yaffs_format(const YCHAR *path,
+		int unmount_flag,
+		int force_unmount_flag,
+		int remount_flag)
+{
+	int retVal = 0;
+	struct yaffs_dev *dev = NULL;
+	int result;
+
+	if (!path) {
+		yaffsfs_SetError(-EFAULT);
+		return -1;
+	}
+
+	if (yaffsfs_CheckPath(path) < 0) {
+		yaffsfs_SetError(-ENAMETOOLONG);
+		return -1;
+	}
+
+	yaffsfs_Lock();
+	dev = yaffsfs_FindMountPoint(path);
+
+	if (dev) {
+		int was_mounted = dev->is_mounted;
+
+		if (dev->is_mounted && unmount_flag) {
+			int inUse;
+			yaffs_flush_whole_cache(dev);
+			yaffs_checkpoint_save(dev);
+			inUse = yaffsfs_IsDevBusy(dev);
+			if (!inUse || force_unmount_flag) {
+				if (inUse)
+					yaffsfs_BreakDeviceHandles(dev);
+				yaffs_deinitialise(dev);
+			}
+		}
+
+		if(dev->is_mounted) {
+				yaffsfs_SetError(-EBUSY);
+				retVal = -1;
+		} else {
+			yaffs_format_dev(dev);
+			if(was_mounted && remount_flag) {
+				result = yaffs_guts_initialise(dev);
+				if (result == YAFFS_FAIL) {
+					yaffsfs_SetError(-ENOMEM);
+					retVal = -1;
+				}
+			}
+		}
+	} else {
+		yaffsfs_SetError(-ENODEV);
+		retVal = -1;
+	}
+
+	yaffsfs_Unlock();
+	return retVal;
+
+}
+
+
 Y_LOFF_T yaffs_freespace(const YCHAR *path)
 {
 	Y_LOFF_T retVal = -1;
diff --git a/direct/yaffsfs.h b/direct/yaffsfs.h
index ba3f87f..b863901 100644
--- a/direct/yaffsfs.h
+++ b/direct/yaffsfs.h
@@ -171,6 +171,10 @@ int yaffs_unmount(const YCHAR *path) ;
 int yaffs_unmount2(const YCHAR *path, int force);
 int yaffs_remount(const YCHAR *path, int force, int read_only);
 
+int yaffs_format(const YCHAR *path,
+		int unmount_flag,
+		int force_unmount_flag,
+		int remount_flag);
 
 int yaffs_sync(const YCHAR *path) ;
 
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 3c1aa10..9f6b409 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -41,7 +41,8 @@
 static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 			     const u8 *buffer, int n_bytes, int use_reserve);
 
-
+static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name,
+				int buffer_size);
 
 /* Function to calculate chunk and offset */
 
@@ -648,15 +649,21 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
 	return sum;
 }
 
+
 void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 {
 	memset(obj->short_name, 0, sizeof(obj->short_name));
-	if (name &&
+
+	if (name && !name[0]) {
+		yaffs_fix_null_name(obj, obj->short_name,
+				YAFFS_SHORT_NAME_LENGTH);
+		name = obj->short_name;
+	} else if (name &&
 		strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
-		YAFFS_SHORT_NAME_LENGTH)
+		YAFFS_SHORT_NAME_LENGTH)  {
 		strcpy(obj->short_name, name);
-	else
-		obj->short_name[0] = _Y('\0');
+	}
+
 	obj->sum = yaffs_calc_name_sum(name);
 }
 
@@ -4992,6 +4999,42 @@ int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 	return n_free;
 }
 
+
+int yaffs_format_dev(struct yaffs_dev *dev)
+{
+	int i;
+	enum yaffs_block_state state;
+	u32 dummy;
+
+	if(dev->is_mounted)
+		return YAFFS_FAIL;
+
+	/*
+	* The runtime variables might not have been set up,
+	* so set up what we need.
+	*/
+	dev->internal_start_block = dev->param.start_block;
+	dev->internal_end_block = dev->param.end_block;
+	dev->block_offset = 0;
+	dev->chunk_offset = 0;
+
+	if (dev->param.start_block == 0) {
+		dev->internal_start_block = dev->param.start_block + 1;
+		dev->internal_end_block = dev->param.end_block + 1;
+		dev->block_offset = 1;
+		dev->chunk_offset = dev->param.chunks_per_block;
+	}
+
+	for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
+		yaffs_query_init_block_state(dev, i, &state, &dummy);
+		if (state != YAFFS_BLOCK_STATE_DEAD)
+			yaffs_erase_block(dev, i);
+	}
+
+	return YAFFS_OK;
+}
+
+
 /*
  * Marshalling functions to get loff_t file sizes into and out of
  * object headers.
diff --git a/yaffs_guts.h b/yaffs_guts.h
index 62d18cb..26ad54d 100644
--- a/yaffs_guts.h
+++ b/yaffs_guts.h
@@ -974,6 +974,8 @@ u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
 
 int yaffs_is_non_empty_dir(struct yaffs_obj *obj);
 
+int yaffs_format_dev(struct yaffs_dev *dev);
+
 void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr,
 				int *chunk_out, u32 *offset_out);
 /*