}
+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];
}
+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;
// link_follow_test("/yaffs2");
//basic_utime_test("/yaffs2");
- max_files_test("/yaffs2");
+
+ //format_test("/yaffs2");
+
+ //max_files_test("/yaffs2");
//start_twice("/yaffs2");
//basic_utime_test("/yaffs2");
//case_insensitive_test("/yaffs2");
+ yy_test("/yaffs2");
+
+
return 0;
}
#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 */
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[])
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[])
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[])
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[])
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[])
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[])
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[])
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[])
}
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[])
}
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[])
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[])
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,
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");
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)
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)
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)
{
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;
#include "yaffs_packedtags2.h"
#include "yaffs_mtdif.h"
#include "yaffs_mtdif2.h"
+#include "yaffs_uboot_glue.h"
+
#if 0
#include <errno.h>
#else
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)
(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;
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;
while (1) {
dev = yaffs_next_dev();
if (!dev)
- return;
+ break;
flash_dev =
((unsigned) dev->driver_context - (unsigned) nand_info)/
sizeof(nand_info[0]);
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,
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;
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) {
}
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);
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;
if (!d) {
printf("opendir failed, %s\n", yaffs_error_str());
- return;
+ return -1;
}
for (i = 0; (de = yaffs_readdir(d)) != NULL; i++) {
}
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;
}
--- /dev/null
+
+#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
#
# Inspired yaffs kernel patching script
-set -e -x
+#set -e -x
UBOOTDIR=$1
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;
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) ;
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 */
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);
}
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.
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);
/*
projects / yaffs2.git / commitdiff