Merge branch 'driver-refactoring' into new-driver-refactoring
authorCharles Manning <cdhmanning@gmail.com>
Tue, 2 Oct 2012 02:41:32 +0000 (15:41 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Tue, 2 Oct 2012 02:41:32 +0000 (15:41 +1300)
direct/test-framework/basic-tests/dtest.c
direct/u-boot/common/cmd_yaffs2.c
direct/u-boot/fs/yaffs2/Makefile
direct/u-boot/fs/yaffs2/yaffs_mtdif.c
direct/u-boot/fs/yaffs2/yaffs_uboot_glue.c
direct/u-boot/fs/yaffs2/yaffs_uboot_glue.h [new file with mode: 0644]
direct/u-boot/patch-u-boot.sh
direct/yaffsfs.c
direct/yaffsfs.h
yaffs_guts.c
yaffs_guts.h

index 153d274..3cd13ab 100644 (file)
@@ -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;
 
 }
index d43a9d4..23cf000 100644 (file)
@@ -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)
 #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");
 
index d2ae2bf..f45c19d 100644 (file)
@@ -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)
 
index db49052..b7ec909 100644 (file)
@@ -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;
index e113e40..f7ac21c 100644 (file)
@@ -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 (file)
index 0000000..d3ae162
--- /dev/null
@@ -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
index 8caa2e8..fc17552 100755 (executable)
@@ -17,7 +17,7 @@
 #
 #  Inspired yaffs kernel patching script
 
-set -e -x
+#set -e -x
 
 UBOOTDIR=$1
 
index def672d..7ee486a 100644 (file)
@@ -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;
index ba3f87f..b863901 100644 (file)
@@ -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) ;
 
index 3c1aa10..9f6b409 100644 (file)
@@ -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.
index 62d18cb..26ad54d 100644 (file)
@@ -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);
 /*