From: charles Date: Fri, 17 Dec 2004 04:39:04 +0000 (+0000) Subject: *** empty log message *** X-Git-Tag: pre-name-change~480 X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=commitdiff_plain;h=37fd9ec3587b5c4d497a7682522a9adfab682e51 *** empty log message *** --- diff --git a/mtdemul/Makefile b/mtdemul/Makefile new file mode 100644 index 0000000..2a2029c --- /dev/null +++ b/mtdemul/Makefile @@ -0,0 +1,33 @@ +#Makefile for NANDemul MTD +# +# NB this is not yet suitable for putting into the kernel tree. +# YAFFS: Yet another FFS. A NAND-flash specific file system. +# +# Copyright (C) 2002 Aleph One Ltd. +# for Toby Churchill Ltd and Brightstar Engineering +# +# Created by Charles Manning +# +# 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. + +## Change or override KERNELDIR to your kernel +## comment out USE_xxxx if you don't want these features. + +KERNELDIR = /usr/src/kernel-headers-2.4.27 + +CFLAGS = -D__KERNEL__ -DMODULE -I$(KERNELDIR)/include -O2 -Wall -g + + + +TARGET = nandemul2k.o + +default: $(TARGET) + +clean: + rm -f $(TARGET) + +$(TARGET): %.o: %.c + gcc -c $(CFLAGS) $< -o $@ + diff --git a/mtdemul/nandemul2k.c b/mtdemul/nandemul2k.c new file mode 100644 index 0000000..2980f9a --- /dev/null +++ b/mtdemul/nandemul2k.c @@ -0,0 +1,696 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + * + * This version hacked for emulating 2kpage NAND for YAFFS2 testing. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define T(f,x) printk x +#define ALLOCATE(x) kmalloc(x,GFP_KERNEL) +#define FREE(x) kfree(x) + + + + + +#define EM_SIZE_IN_MEG 4 +#define PAGE_DATA_SIZE (2048) +#define PAGE_SPARE_SIZE (64) +#define PAGES_PER_BLOCK (64) +#define NAND_SHIFT (11) // Shifter for 2k + + +#define EM_SIZE_IN_BYTES (EM_SIZE_IN_MEG * (1<<20)) + +#define PAGE_TOTAL_SIZE (PAGE_DATA_SIZE+PAGE_SPARE_SIZE) + +#define BLOCK_TOTAL_SIZE (PAGES_PER_BLOCK * PAGE_TOTAL_SIZE) + +#define BLOCKS_PER_MEG ((1<<20)/(PAGES_PER_BLOCK * PAGE_DATA_SIZE)) + + +static struct mtd_info nandemul2k_mtd; + +typedef struct +{ + __u8 data[PAGE_TOTAL_SIZE]; // Data + spare + int empty; // is this empty? +} nandemul_Page; + + +typedef struct +{ + nandemul_Page *page[PAGES_PER_BLOCK]; + int damaged; +} nandemul_Block; + + + +typedef struct +{ + nandemul_Block**block; + int nBlocks; +} nandemul_Device; + +static nandemul_Device ned; + +static int sizeInMB = EM_SIZE_IN_MEG; + + +static void nandemul_yield(int n) +{ +#ifdef __KERNEL__ + if(n > 0) schedule_timeout(n); +#endif + +} + + +static void nandemul2k_Read(void *buffer, int page, int start, int nBytes) +{ + int pg = page%PAGES_PER_BLOCK; + int blk = page/PAGES_PER_BLOCK; + if(buffer && nBytes > 0) + { + memcpy(buffer,&ned.block[blk]->page[pg]->data[start],nBytes); + } + +} + +static void nandemul2k_Program(const void *buffer, int page, int start, int nBytes) +{ + int pg = page%PAGES_PER_BLOCK; + int blk = page/PAGES_PER_BLOCK; + __u8 *p; + __u8 *b = (__u8 *)buffer; + + p = &ned.block[blk]->page[pg]->data[start]; + + while(buffer && nBytes>0) + { + *p = *p & *b; + p++; + b++; + nBytes--; + } +} + +static void nandemul2k_DoErase(int blockNumber) +{ + int i; + + nandemul_Block *blk; + + if(blockNumber < 0 || blockNumber >= ned.nBlocks) + { + return; + } + + blk = ned.block[blockNumber]; + + for(i = 0; i < PAGES_PER_BLOCK; i++) + { + memset(blk->page[i],0xff,sizeof(nandemul_Page)); + blk->page[i]->empty = 1; + } + nandemul_yield(2); +} + + +static int nandemul2k_CalcNBlocks(void) +{ + return EM_SIZE_IN_MEG * BLOCKS_PER_MEG; +} + + + +static int CheckInit(void) +{ + static int initialised = 0; + + int i,j; + + int fail = 0; + int nBlocks; + + int nAllocated = 0; + + if(initialised) + { + return 0; + } + + + ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks(); + + + ned.block = ALLOCATE(sizeof(nandemul_Block*) * nBlocks ); + + if(!ned.block) return ENOMEM; + + + + + + for(i=fail=0; i page[j] = ALLOCATE(sizeof(nandemul_Page))) == 0) + { + fail = 1; + } + } + nandemul2k_DoErase(i); + ned.block[i]->damaged = 0; + nAllocated++; + } + } + + if(fail) + { + //Todo thump pages + + for(i = 0; i < nAllocated; i++) + { + FREE(ned.block[i]); + } + FREE(ned.block); + + return ENOMEM; + } + + ned.nBlocks = nBlocks; + + initialised = 1; + + return 1; +} + + + +static void nandemul2k_CleanUp(void) +{ + int i,j; + + for(i = 0; i < ned.nBlocks; i++) + { + for(j = 0; j < PAGES_PER_BLOCK; j++) + { + FREE(ned.block[i]->page[j]); + } + FREE(ned.block[i]); + + } + FREE(ned.block); + ned.block = 0; +} + +int nandemul2k_GetBytesPerChunk(void) { return PAGE_DATA_SIZE;} + +int nandemul2k_GetChunksPerBlock(void) { return PAGES_PER_BLOCK; } +int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();} + + + +int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId) +{ + *vendorId = 'Y'; + *deviceId = '2'; + + return 1; +} + + +int nandemul2k_ReadStatus(__u8 *status) +{ + *status = 0; + return 1; +} + + +#ifdef CONFIG_MTD_NAND_ECC +#include +#endif + +/* + * NAND low-level MTD interface functions + */ +static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf); +static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf, u_char *oob_buf, struct nand_oobinfo *dummy); +static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf); +static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf); +static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf, + const u_char *oob_buf, struct nand_oobinfo *dummy); +static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf); +static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs, + unsigned long count, loff_t to, size_t *retlen); +static int nand_erase (struct mtd_info *mtd, struct erase_info *instr); +static void nand_sync (struct mtd_info *mtd); + + + +/* + * NAND read + */ +static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf) +{ + return nand_read_ecc (mtd, from, len, retlen, buf, NULL,NULL); +} + + +/* + * NAND read with ECC + */ +static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf, u_char *oob_buf,struct nand_oobinfo *oobsel) +{ + int start, page; + int n = len; + int nToCopy; + + + + /* Do not allow reads past end of device */ + if ((from + len) > mtd->size) { + *retlen = 0; + return -EINVAL; + } + + + /* Initialize return value */ + *retlen = 0; + + while(n > 0) + { + + /* First we calculate the starting page */ + page = from >> NAND_SHIFT; + + /* Get raw starting column */ + + start = from & (mtd->oobblock-1); + + // OK now check for the curveball where the start and end are in + // the same page + if((start + n) < mtd->oobblock) + { + nToCopy = n; + } + else + { + nToCopy = mtd->oobblock - start; + } + + nandemul2k_Read(buf, page, start, nToCopy); + nandemul2k_Read(oob_buf,page,PAGE_DATA_SIZE,PAGE_SPARE_SIZE); + + n -= nToCopy; + from += nToCopy; + buf += nToCopy; + if(oob_buf) oob_buf += PAGE_SPARE_SIZE; + *retlen += nToCopy; + + } + + + return 0; +} + +/* + * NAND read out-of-band + */ +static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf) +{ + int col, page; + + T(0,("nand_read_oob: from = 0x%08x, buf = 0x%08x, len = %i\n", (unsigned int) from, (unsigned int) buf, + (int) len)); + + /* Shift to get page */ + page = ((int) from) >> NAND_SHIFT; + + /* Mask to get column */ + col = from & 0x0f; + + /* Initialize return length value */ + *retlen = 0; + + /* Do not allow reads past end of device */ + if ((from + len) > mtd->size) { + T(0, + ("nand_read_oob: Attempt read beyond end of device\n")); + *retlen = 0; + return -EINVAL; + } + + nandemul2k_Read(buf,page,PAGE_DATA_SIZE + col,len); + + /* Return happy */ + *retlen = len; + return 0; +} + +/* + * NAND write + */ +static int nand_write (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf) +{ + return nand_write_ecc (mtd, to, len, retlen, buf, NULL,NULL); +} + +/* + * NAND write with ECC + */ +static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf, + const u_char *oob_buf, struct nand_oobinfo *dummy) +{ + + int start, page; + int n = len; + int nToCopy; + + + + /* Do not allow reads past end of device */ + if ((to + len) > mtd->size) { + *retlen = 0; + return -EINVAL; + } + + + /* Initialize return value */ + *retlen = 0; + + while(n > 0) + { + + /* First we calculate the starting page */ + page = to >> NAND_SHIFT; + + /* Get raw starting column */ + + start = to & (mtd->oobblock - 1); + + // OK now check for the curveball where the start and end are in + // the same page + if((start + n) < mtd->oobblock) + { + nToCopy = n; + } + else + { + nToCopy = mtd->oobblock - start; + } + + nandemul2k_Program(buf, page, start, nToCopy); + nandemul2k_Program(oob_buf, page, PAGE_DATA_SIZE, PAGE_SPARE_SIZE); + + n -= nToCopy; + to += nToCopy; + buf += nToCopy; + if(oob_buf) oob_buf += PAGE_SPARE_SIZE; + *retlen += nToCopy; + + } + + + return 0; +} + +/* + * NAND write out-of-band + */ +static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf) +{ + int col, page; + + + T(0,( + "nand_read_oob: to = 0x%08x, len = %i\n", (unsigned int) to, + (int) len)); + + /* Shift to get page */ + page = ((int) to) >> NAND_SHIFT; + + /* Mask to get column */ + col = to & 0x0f; + + /* Initialize return length value */ + *retlen = 0; + + /* Do not allow reads past end of device */ + if ((to + len) > mtd->size) { + T(0,( + "nand_read_oob: Attempt read beyond end of device\n")); + *retlen = 0; + return -EINVAL; + } + + nandemul2k_Program(buf,page,512 + col,len); + + /* Return happy */ + *retlen = len; + return 0; + +} + +/* + * NAND write with iovec + */ +static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs, + unsigned long count, loff_t to, size_t *retlen) +{ + return -EINVAL; +} + +/* + * NAND erase a block + */ +static int nand_erase (struct mtd_info *mtd, struct erase_info *instr) +{ + int i, nBlocks,block; + + T(0,( + "nand_erase: start = 0x%08x, len = %i\n", + (unsigned int) instr->addr, (unsigned int) instr->len)); + + /* Start address must align on block boundary */ + if (instr->addr & (mtd->erasesize - 1)) { + T(0,( + "nand_erase: Unaligned address\n")); + return -EINVAL; + } + + /* Length must align on block boundary */ + if (instr->len & (mtd->erasesize - 1)) { + T(0,( + "nand_erase: Length not block aligned\n")); + return -EINVAL; + } + + /* Do not allow erase past end of device */ + if ((instr->len + instr->addr) > mtd->size) { + T(0,( + "nand_erase: Erase past end of device\n")); + return -EINVAL; + } + + nBlocks = instr->len >> (NAND_SHIFT + 5); + block = instr->addr >> (NAND_SHIFT + 5); + + for(i = 0; i < nBlocks; i++) + { + nandemul2k_DoErase(block); + block++; + } + + + + return 0; + + +} + + +int nand_block_isbad(struct mtd_info *mtd,int blockNo) +{ + return 0; +} + +int nand_block_markbad(struct mtd_info *mtd, int blockNo) +{ + return 0; +} + + +/* + * NAND sync + */ +static void nand_sync (struct mtd_info *mtd) +{ + T(0,("nand_sync: called\n")); + +} + +/* + * Scan for the NAND device + */ +int nand_scan (struct mtd_info *mtd,int nchips) +{ + mtd->oobblock = PAGE_DATA_SIZE; + mtd->oobsize = PAGE_SPARE_SIZE; + mtd->erasesize = PAGE_DATA_SIZE * PAGES_PER_BLOCK; + mtd->size = sizeInMB * 1024*1024; + + + + /* Fill in remaining MTD driver data */ + mtd->type = MTD_NANDFLASH; + mtd->flags = MTD_CAP_NANDFLASH; + mtd->owner = THIS_MODULE; + mtd->ecctype = MTD_ECC_NONE; + mtd->erase = nand_erase; + mtd->point = NULL; + mtd->unpoint = NULL; + mtd->read = nand_read; + mtd->write = nand_write; + mtd->read_ecc = nand_read_ecc; + mtd->write_ecc = nand_write_ecc; + mtd->read_oob = nand_read_oob; + mtd->write_oob = nand_write_oob; + mtd->block_isbad = nand_block_isbad; + mtd->block_markbad = nand_block_markbad; + mtd->readv = NULL; + mtd->writev = nand_writev; + mtd->sync = nand_sync; + mtd->lock = NULL; + mtd->unlock = NULL; + mtd->suspend = NULL; + mtd->resume = NULL; + + /* Return happy */ + return 0; +} + +#if 0 +#ifdef MODULE +MODULE_PARM(sizeInMB, "i"); + +__setup("sizeInMB=",sizeInMB); +#endif +#endif + +/* + * Define partitions for flash devices + */ + +static struct mtd_partition nandemul2k_partition[] = +{ + { name: "NANDemul partition 1", + offset: 0, + size: 0 }, +}; + +static int nPartitions = sizeof(nandemul2k_partition)/sizeof(nandemul2k_partition[0]); + +/* + * Main initialization routine + */ +int __init nandemul2k_init (void) +{ + + // Do the nand init + + CheckInit(); + + nand_scan(&nandemul2k_mtd,1); + + // Build the partition table + + nandemul2k_partition[0].size = sizeInMB * 1024 * 1024; + + // Register the partition + add_mtd_partitions(&nandemul2k_mtd,nandemul2k_partition,nPartitions); + + return 0; + +} + +module_init(nandemul2k_init); + +/* + * Clean up routine + */ +#ifdef MODULE +static void __exit nandemul2k_cleanup (void) +{ + + nandemul2k_CleanUp(); + + /* Unregister partitions */ + del_mtd_partitions(&nandemul2k_mtd); + + /* Unregister the device */ + del_mtd_device (&nandemul2k_mtd); + +} +module_exit(nandemul2k_cleanup); +#endif + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Charles Manning "); +MODULE_DESCRIPTION("2k Page/128k Block NAND emulated in RAM"); + + + + diff --git a/yaffs_fs.c b/yaffs_fs.c new file mode 100644 index 0000000..f25bccc --- /dev/null +++ b/yaffs_fs.c @@ -0,0 +1,1915 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_fs.c + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + * This is the file system front-end to YAFFS that hooks it up to + * the VFS. + * + * Special notes: + * >> sb->u.generic_sbp points to the yaffs_Device associated with this superblock + * >> inode->u.generic_ip points to the associated yaffs_Object. + * + * + * Acknowledgements: + * * Luc van OostenRyck for numerous patches. + * * Nick Bane for numerous patches. + * * Nick Bane for 2.5/2.6 integration. + * * Andras Toth for mknod rdev issue. + * * Michael Fischer for finding the problem with inode inconsistency. + * * Some code bodily lifted from JFFS2. + */ + + +const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.1 2004-12-17 04:39:04 charles Exp $"; +extern const char *yaffs_guts_c_version; + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) + +#include /* Added NCB 15-8-2003 */ +#include +#define UnlockPage(p) unlock_page(p) +#define Page_Uptodate(page) test_bit(PG_uptodate, &(page)->flags) +//#define kdevname(x) cdevname(to_kdev_t(x)) +#define kdevname(x) "(unavailable)" // temporary fix + +#else + +#include + +#endif + + +#include + +#include "yportenv.h" +#include "yaffs_guts.h" + + + + +//unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS; +unsigned yaffs_traceMask = 0xFFFFFFFF; + + +#ifdef CONFIG_YAFFS_RAM_ENABLED +#include "yaffs_nandemul.h" +// 2 MB of RAM for emulation +#define YAFFS_RAM_EMULATION_SIZE 0x200000 +#endif //CONFIG_YAFFS_RAM_ENABLED + +#if CONFIG_YAFFS2_RAM_ENABLED +#include "yaffs_nandemul2k.h" +#endif + +#ifdef CONFIG_YAFFS_MTD_ENABLED +#include +#include "yaffs_mtdif.h" +#include "yaffs_mtdif2.h" +#endif //CONFIG_YAFFS_MTD_ENABLED + +//#define T(x) printk x + + + +#define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip)) +#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode) +//NCB #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp) + +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info) +#else +#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp) +#endif + + +static void yaffs_put_super(struct super_block *sb); + +#if 0 +static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos); +#endif + +static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos); + +static int yaffs_file_flush(struct file* file); + +static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync); + +static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); + +//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); +static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *n); +#else +static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode); +static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry); +#endif +static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry); +static int yaffs_unlink(struct inode * dir, struct dentry *dentry); +static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname); +static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode); + +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev); +#else +static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev); +#endif +static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry); +static int yaffs_setattr(struct dentry *dentry, struct iattr *attr); + +//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf); +#else +static int yaffs_statfs(struct super_block *sb, struct statfs *buf); +#endif +static void yaffs_read_inode (struct inode *inode); + +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static struct super_block *yaffs_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data); +#else +static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent); +#endif + +static void yaffs_put_inode (struct inode *inode); +static void yaffs_delete_inode(struct inode *); +static void yaffs_clear_inode(struct inode *); + +static int yaffs_readpage(struct file *file, struct page * page); +static int yaffs_writepage(struct page *page); +static int yaffs_prepare_write(struct file *f, struct page *pg, unsigned offset, unsigned to); +static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, unsigned to); + +static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen); +static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); + + + + +static struct address_space_operations yaffs_file_address_operations = { + readpage: yaffs_readpage, + writepage: yaffs_writepage, + prepare_write: yaffs_prepare_write, + commit_write: yaffs_commit_write +}; + + +static struct file_operations yaffs_file_operations = { + + read: generic_file_read, + write: generic_file_write, + + mmap: generic_file_mmap, + flush: yaffs_file_flush, + fsync: yaffs_sync_object, +}; + + +static struct inode_operations yaffs_file_inode_operations = { + setattr: yaffs_setattr, +}; + + +struct inode_operations yaffs_symlink_inode_operations = +{ + readlink: yaffs_readlink, + follow_link: yaffs_follow_link, + setattr: yaffs_setattr +}; + +static struct inode_operations yaffs_dir_inode_operations = { + create: yaffs_create, + lookup: yaffs_lookup, + link: yaffs_link, + unlink: yaffs_unlink, + symlink: yaffs_symlink, + mkdir: yaffs_mkdir, + rmdir: yaffs_unlink, + mknod: yaffs_mknod, + rename: yaffs_rename, + setattr: yaffs_setattr, +}; + +static struct file_operations yaffs_dir_operations = { + read: generic_read_dir, + readdir: yaffs_readdir, + fsync: yaffs_sync_object, +}; + + +static struct super_operations yaffs_super_ops = { + statfs: yaffs_statfs, + read_inode: yaffs_read_inode, + put_inode: yaffs_put_inode, + put_super: yaffs_put_super, +// remount_fs: + delete_inode: yaffs_delete_inode, + clear_inode: yaffs_clear_inode, +}; + + + +static void yaffs_GrossLock(yaffs_Device *dev) +{ + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs locking\n")); + + down(&dev->grossLock); +} + +static void yaffs_GrossUnlock(yaffs_Device *dev) +{ + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs unlocking\n")); + up(&dev->grossLock); + +} + +static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen) +{ + unsigned char *alias; + int ret; + + yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + + + yaffs_GrossLock(dev); + + alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); + + yaffs_GrossUnlock(dev); + + if(!alias) + return -ENOMEM; + + ret = vfs_readlink(dentry, buffer, buflen, alias); + kfree(alias); + return ret; +} + +static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) +{ + unsigned char *alias; + int ret; + yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + + + yaffs_GrossLock(dev); + + alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); + + yaffs_GrossUnlock(dev); + + if(!alias) + return -ENOMEM; + + ret = vfs_follow_link(nd,alias); + kfree(alias); + return ret; +} + + +struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj); + +/* + * Lookup is used to find objects in the fs + */ +//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) + +static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *n) +#else +static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry) +#endif +{ + yaffs_Object *obj; + struct inode *inode = NULL; // NCB 2.5/2.6 needs NULL here + + yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev; + + + yaffs_GrossLock(dev); + + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup for %d:%s\n",yaffs_InodeToObject(dir)->objectId,dentry->d_name.name)); + + obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir),dentry->d_name.name); + + obj = yaffs_GetEquivalentObject(obj); // in case it was a hardlink + + + + if(obj) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup found %d\n",obj->objectId)); + + inode = yaffs_get_inode(dir->i_sb, obj->st_mode,0,obj); + + if(inode) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_loookup dentry \n")); +/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to d_add even if NULL inode */ +#if 0 + //dget(dentry); // try to solve directory bug + d_add(dentry,inode); + + yaffs_GrossUnlock(dev); + + // return dentry; + return NULL; +#endif + } + + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup not found\n")); + + } + yaffs_GrossUnlock(dev); + +/* added NCB for 2.5/6 compatability - forces add even if inode is NULL which creates dentry hash*/ + d_add(dentry,inode); + + return NULL; + // return (ERR_PTR(-EIO)); + +} + +// For now put inode is just for debugging +// Put inode is called when the inode **structure** is put. +static void yaffs_put_inode(struct inode *inode) +{ + T(YAFFS_TRACE_OS,("yaffs_put_inode: ino %d, count %d\n",(int)inode->i_ino, atomic_read(&inode->i_count))); + +} + +// clear is called to tell the fs to release any per-inode data it holds +static void yaffs_clear_inode(struct inode *inode) +{ + yaffs_Object *obj; + yaffs_Device *dev; + + obj = yaffs_InodeToObject(inode); + + T(YAFFS_TRACE_OS,("yaffs_clear_inode: ino %d, count %d %s\n",(int)inode->i_ino, atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); + + if(obj) + { + dev = obj->myDev; + yaffs_GrossLock(dev); + + // Clear the association between the inode ant the yaffs_Object. + obj->myInode = NULL; + inode->u.generic_ip = NULL; + + // If the object freeing was deferred, then the real free happens now. + // This should fix the inode inconsistency problem. + + yaffs_HandleDeferedFree(obj); + + yaffs_GrossUnlock(dev); + } + + +} + +// delete is called when the link count is zero and the inode +// is put (ie. nobody wants to know about it anymore, time to +// delete the file). +// NB Must call clear_inode() +static void yaffs_delete_inode(struct inode *inode) +{ + yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,("yaffs_delete_inode: ino %d, count %d %s\n",(int)inode->i_ino, atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); + + if(obj) + { + dev = obj->myDev; + yaffs_GrossLock(dev); + yaffs_DeleteFile(obj); + yaffs_GrossUnlock(dev); + } + clear_inode(inode); +} + + +static int yaffs_file_flush(struct file* file) +{ + yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry); + + yaffs_Device *dev = obj->myDev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_flush object %d (%s)\n",obj->objectId, + obj->dirty ? "dirty" : "clean")); + + yaffs_GrossLock(dev); + + yaffs_FlushFile(obj,1); + + yaffs_GrossUnlock(dev); + + return 0; +} + + + +static int yaffs_readpage_nolock(struct file *f, struct page * pg) +{ + // Lifted from jffs2 + + yaffs_Object *obj; + unsigned char *pg_buf; + int ret; + + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readpage at %08x, size %08x\n", + (unsigned)(pg->index << PAGE_CACHE_SHIFT), (unsigned)PAGE_CACHE_SIZE)); + + obj = yaffs_DentryToObject(f->f_dentry); + + dev = obj->myDev; + + + if (!PageLocked(pg)) + PAGE_BUG(pg); + + pg_buf = kmap(pg); + /* FIXME: Can kmap fail? */ + + yaffs_GrossLock(dev); + + ret = yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); + + yaffs_GrossUnlock(dev); + + if(ret >= 0) ret = 0; + + if (ret) { + ClearPageUptodate(pg); + SetPageError(pg); + } else { + SetPageUptodate(pg); + ClearPageError(pg); + } + + flush_dcache_page(pg); + kunmap(pg); + + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readpage done\n")); + return ret; +} + +static int yaffs_readpage_unlock(struct file *f, struct page *pg) +{ + int ret = yaffs_readpage_nolock(f,pg); + UnlockPage(pg); + return ret; +} + +static int yaffs_readpage(struct file *f, struct page * pg) +{ + return yaffs_readpage_unlock(f,pg); +} + +// writepage inspired by/stolen from smbfs +// + +static int yaffs_writepage(struct page *page) +{ + struct address_space *mapping = page->mapping; + struct inode *inode; + unsigned long end_index; + char *buffer; + yaffs_Object *obj; + int nWritten = 0; + unsigned nBytes; + + if (!mapping) + BUG(); + inode = mapping->host; + if (!inode) + BUG(); + + end_index = inode->i_size >> PAGE_CACHE_SHIFT; + + /* easy case */ + if (page->index < end_index) + { + nBytes = PAGE_CACHE_SIZE; + } + else + { + nBytes = inode->i_size & (PAGE_CACHE_SIZE-1); + } + // What's happening here? + ///* OK, are we completely out? */ + //if (page->index >= end_index+1 || !offset) + // return -EIO; + + get_page(page); + + + buffer = kmap(page); + + obj = yaffs_InodeToObject(inode); + yaffs_GrossLock(obj->myDev); + + + nWritten = yaffs_WriteDataToFile(obj,buffer,page->index << PAGE_CACHE_SHIFT,nBytes); + + yaffs_GrossUnlock(obj->myDev); + + kunmap(page); + SetPageUptodate(page); + UnlockPage(page); + put_page(page); + + return (nWritten == nBytes) ? 0 : -ENOSPC; +} + + + +static int yaffs_prepare_write(struct file *f, struct page *pg, unsigned offset, unsigned to) +{ + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_prepair_write\n")); + if(!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE)) + return yaffs_readpage_nolock(f,pg); + + return 0; + +} + +static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, unsigned to) +{ + + void *addr = page_address(pg) + offset; + loff_t pos = (((loff_t)pg->index) << PAGE_CACHE_SHIFT) + offset; + int nBytes = to - offset; + int nWritten; + + unsigned spos = pos; + unsigned saddr = (unsigned)addr; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write addr %x pos %x nBytes %d\n",saddr,spos,nBytes)); + + nWritten = yaffs_file_write(f,addr, nBytes, &pos); + + if(nWritten != nBytes) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write not same size nWritten %d nBytes %d\n",nWritten,nBytes)); + SetPageError(pg); + ClearPageUptodate(pg); + } + else + { + SetPageUptodate(pg); + } + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_commit_write returning %d\n",nWritten)); + + return nWritten; + +} + + + +static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) +{ + if (inode && obj) + { + inode->i_ino = obj->objectId; + inode->i_mode = obj->st_mode; + inode->i_uid = obj->st_uid; + inode->i_gid = obj->st_gid; + inode->i_blksize = inode->i_sb->s_blocksize; +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) + + inode->i_rdev = old_decode_dev(obj->st_rdev); + inode->i_atime.tv_sec = (time_t)(obj->st_atime); + inode->i_atime.tv_nsec = 0; + inode->i_mtime.tv_sec = (time_t)obj->st_mtime; + inode->i_mtime.tv_nsec =0; + inode->i_ctime.tv_sec = (time_t)obj->st_ctime; + inode->i_ctime.tv_nsec = 0; +#else + inode->i_rdev = obj->st_rdev; + inode->i_atime = obj->st_atime; + inode->i_mtime = obj->st_mtime; + inode->i_ctime = obj->st_ctime; +#endif + inode->i_size = yaffs_GetObjectFileLength(obj); + inode->i_blocks = (inode->i_size + 511) >> 9; + + inode->i_nlink = yaffs_GetObjectLinkCount(obj); + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_FillInode mode %x uid %d gid %d size %d count %d\n", + inode->i_mode, inode->i_uid, inode->i_gid, (int)inode->i_size, atomic_read(&inode->i_count))); + + switch (obj->st_mode & S_IFMT) + { + default: // fifo, device or socket + init_special_inode(inode, obj->st_mode,(dev_t)(obj->st_rdev)); + break; + case S_IFREG: // file + inode->i_op = &yaffs_file_inode_operations; + inode->i_fop = &yaffs_file_operations; + inode->i_mapping->a_ops = &yaffs_file_address_operations; + break; + case S_IFDIR: // directory + inode->i_op = &yaffs_dir_inode_operations; + inode->i_fop = &yaffs_dir_operations; + break; + case S_IFLNK: // symlink + inode->i_op = &yaffs_symlink_inode_operations; + break; + } + + + inode->u.generic_ip = obj; + obj->myInode = inode; + + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_FileInode invalid parameters\n")); + } + +} + +struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Object *obj) +{ + struct inode * inode; + + if(!sb) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_get_inode for NULL super_block!!\n")); + return NULL; + + } + + if(!obj) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_get_inode for NULL object!!\n")); + return NULL; + + } + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_get_inode for object %d\n",obj->objectId)); + + inode = iget(sb,obj->objectId); + + // NB Side effect: iget calls back to yaffs_read_inode(). + // iget also increments the inode's i_count + + return inode; +} + +#if 0 + +// No longer used because we use generic rw */ +static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos) +{ + yaffs_Object *obj; + int nRead,ipos; + struct inode *inode; + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read\n")); + + obj = yaffs_DentryToObject(f->f_dentry); + + dev = obj->myDev; + + yaffs_GrossLock(dev); + + inode = f->f_dentry->d_inode; + + if (*pos < inode->i_size) + { + if (*pos + n > inode->i_size) + { + n = inode->i_size - *pos; + } + } + else + { + n = 0; + } + + nRead = yaffs_ReadDataFromFile(obj,buf,*pos,n); + if(nRead > 0) + { + f->f_pos += nRead; + } + + yaffs_GrossUnlock(dev); + + ipos = *pos; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read read %d bytes, %d read at %d\n",n,nRead,ipos)); + return nRead; + +} + +#endif + +static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos) +{ + yaffs_Object *obj; + int nWritten,ipos; + struct inode *inode; + yaffs_Device *dev; + + + obj = yaffs_DentryToObject(f->f_dentry); + + dev = obj->myDev; + + yaffs_GrossLock(dev); + + inode = f->f_dentry->d_inode; + + if(!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) + { + ipos = inode->i_size; + } + else + { + ipos = *pos; + } + + + if(!obj) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write: hey obj is null!\n")); + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write about to write writing %d bytes to object %d at %d\n",n,obj->objectId,ipos)); + } + + nWritten = yaffs_WriteDataToFile(obj,buf,ipos,n); + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write writing %d bytes, %d written at %d\n",n,nWritten,ipos)); + if(nWritten > 0) + { + ipos += nWritten; + *pos = ipos; + if(ipos > inode->i_size) + { + inode->i_size = ipos; + inode->i_blocks = (ipos + 511)>>9; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write size updated to %d bytes, %d blocks\n",ipos,(int)(inode->i_blocks))); + } + + } + yaffs_GrossUnlock(dev); + + return nWritten != n ? -ENOSPC : nWritten; +} + + + +static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) +{ + yaffs_Object *obj; + yaffs_Device *dev; + struct inode *inode = f->f_dentry->d_inode; + unsigned long offset, curoffs; + struct list_head *i; + yaffs_Object *l; + + char name[YAFFS_MAX_NAME_LENGTH +1]; + + obj = yaffs_DentryToObject(f->f_dentry); + dev = obj->myDev; + + yaffs_GrossLock(dev); + + offset = f->f_pos; + + T(YAFFS_TRACE_OS,("yaffs_readdir: starting at %d\n",(int)offset)); + + if(offset == 0) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: entry . ino %d \n",(int)inode->i_ino)); + if(filldir(dirent,".",1,offset,inode->i_ino,DT_DIR) < 0) + { + goto out; + } + offset++; + f->f_pos++; + } + if(offset == 1) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: entry .. ino %d \n",(int)f->f_dentry->d_parent->d_inode->i_ino)); + if(filldir(dirent,"..",2,offset,f->f_dentry->d_parent->d_inode->i_ino,DT_DIR) < 0) + { + goto out; + } + offset++; + f->f_pos++; + } + + curoffs = 1; + + list_for_each(i,&obj->variant.directoryVariant.children) + { + curoffs++; + if(curoffs >= offset) + { + l = list_entry(i, yaffs_Object,siblings); + + yaffs_GetObjectName(l,name,YAFFS_MAX_NAME_LENGTH+1); + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_readdir: %s inode %d\n",name,yaffs_GetObjectInode(l))); + + if(filldir(dirent, + name, + strlen(name), + offset, + yaffs_GetObjectInode(l), + yaffs_GetObjectType(l)) + < 0) + { + goto up_and_out; + } + + offset++; + f->f_pos++; + } + } + + up_and_out: + out: + + yaffs_GrossUnlock(dev); + + return 0; +} + + +/* + * File creation. Allocate an inode, and we're done.. + */ +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev) +#else +static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev) +#endif +{ + struct inode *inode; + + yaffs_Object *obj = NULL; + yaffs_Device *dev; + + yaffs_Object *parent = yaffs_InodeToObject(dir); + + int error = -ENOSPC; + + if(parent) + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: parent object %d type %d\n", + parent->objectId,parent->variantType)); + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: could not get parent object\n")); + return -EPERM; + } + + T(YAFFS_TRACE_OS,("yaffs_mknod: making oject for %s, mode %x dev %x\n", + dentry->d_name.name, mode,rdev)); + + dev = parent->myDev; + + yaffs_GrossLock(dev); + + switch (mode & S_IFMT) + { + default: + // Special (socket, fifo, device...) + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making special\n")); + obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,current->uid, current->gid,rdev); + break; + case S_IFREG: // file + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n")); + obj = yaffs_MknodFile(parent,dentry->d_name.name,mode,current->uid, current->gid); + break; + case S_IFDIR: // directory + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making directory\n")); + obj = yaffs_MknodDirectory(parent,dentry->d_name.name,mode,current->uid, current->gid); + break; + case S_IFLNK: // symlink + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n")); + obj = NULL; // Do we ever get here? + break; + } + + if(obj) + { + inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj); + d_instantiate(dentry, inode); + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod created object %d count = %d\n",obj->objectId,atomic_read(&inode->i_count))); + error = 0; + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod failed making object\n")); + error = -ENOMEM; + } + + yaffs_GrossUnlock(dev); + + return error; +} + +static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode) +{ + int retVal; + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mkdir\n")); + retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0); +#if 0 + // attempt to fix dir bug - didn't work + if(!retVal) + { + dget(dentry); + } +#endif + return retVal; +} + +//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n) +#else +static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode) +#endif +{ + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_create\n")); + return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); +} + + +static int yaffs_unlink(struct inode * dir, struct dentry *dentry) +{ + int retVal; + + yaffs_Device *dev; + + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_unlink %d:%s\n",(int)(dir->i_ino),dentry->d_name.name)); + + dev = yaffs_InodeToObject(dir)->myDev; + + yaffs_GrossLock(dev); + + + retVal = yaffs_Unlink(yaffs_InodeToObject(dir),dentry->d_name.name); + + + yaffs_GrossUnlock(dev); + + if( retVal == YAFFS_OK) + { + dentry->d_inode->i_nlink--; + mark_inode_dirty(dentry->d_inode); + return 0; + } + else + { + return -ENOTEMPTY; + } +} + + +/* + * Create a link... + */ +static int yaffs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry) +{ + struct inode *inode = old_dentry->d_inode; + yaffs_Object *obj = NULL; + yaffs_Object *link=NULL; + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_link\n")); + + obj = yaffs_InodeToObject(inode); + dev = obj->myDev; + + yaffs_GrossLock(dev); + + if (!S_ISDIR(inode->i_mode)) // Don't link directories + { + link = yaffs_Link(yaffs_InodeToObject(dir),dentry->d_name.name,obj); + } + + + if(link) + { + old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj); + d_instantiate(dentry, old_dentry->d_inode); + atomic_inc(&old_dentry->d_inode->i_count); + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_link link count %d i_count %d\n", + old_dentry->d_inode->i_nlink,atomic_read(&old_dentry->d_inode->i_count))); + + } + + yaffs_GrossUnlock(dev); + + + if(link) + { + + return 0; + } + + + return -EPERM; +} + + +static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) +{ + yaffs_Object *obj; + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_symlink\n")); + + dev = yaffs_InodeToObject(dir)->myDev; + yaffs_GrossLock(dev); + obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name, + S_IFLNK | S_IRWXUGO, current->uid, current->gid, + symname); + yaffs_GrossUnlock(dev); + + if(obj) + { + + struct inode* inode; + + inode = yaffs_get_inode(dir->i_sb, obj->st_mode, 0, obj); + d_instantiate(dentry, inode); + T(YAFFS_TRACE_OS,(KERN_DEBUG"symlink created OK\n")); + return 0; + } + else + { + T(YAFFS_TRACE_OS,(KERN_DEBUG"symlink not created\n")); + + } + + return -ENOMEM; +} + +static int yaffs_sync_object(struct file * file, struct dentry *dentry, int datasync) +{ + + yaffs_Object *obj; + yaffs_Device *dev; + + obj = yaffs_DentryToObject(dentry); + + dev = obj->myDev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_sync_object\n")); + yaffs_GrossLock(dev); + yaffs_FlushFile(obj,1); + yaffs_GrossUnlock(dev); + return 0; +} + +/* + * The VFS layer already does all the dentry stuff for rename. + * + * NB: POSIX says you can rename an object over an old object of the same name + */ +static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry) +{ + yaffs_Device *dev; + int retVal = YAFFS_FAIL; + int removed = 0; + yaffs_Object *target; + + dev = yaffs_InodeToObject(old_dir)->myDev; + + yaffs_GrossLock(dev); + + // Check if the target is an existing directory that is not empty. + target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),new_dentry->d_name.name); + + if(target && + target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && + !list_empty(&target->variant.directoryVariant.children)) + { + retVal = YAFFS_FAIL; + } + else + { + + // Unlink the target if it exists + removed = yaffs_Unlink(yaffs_InodeToObject(new_dir),new_dentry->d_name.name); + + + retVal = yaffs_RenameObject(yaffs_InodeToObject(old_dir),old_dentry->d_name.name, + yaffs_InodeToObject(new_dir),new_dentry->d_name.name); + + } + yaffs_GrossUnlock(dev); + + if(retVal == YAFFS_OK) + { + if(removed == YAFFS_OK) + { + new_dentry->d_inode->i_nlink--; + mark_inode_dirty(new_dentry->d_inode); + } + + return 0; + } + else + { + return -ENOTEMPTY; + } + + +} + +static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + int error; + yaffs_Device *dev; + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_setattr of object %d\n",yaffs_InodeToObject(inode)->objectId)); + + if((error = inode_change_ok(inode,attr)) == 0) + { + + dev = yaffs_InodeToObject(inode)->myDev; + yaffs_GrossLock(dev); + if(yaffs_SetAttributes(yaffs_InodeToObject(inode),attr) == YAFFS_OK) + { + error = 0; + } + else + { + error = -EPERM; + } + yaffs_GrossUnlock(dev); + inode_setattr(inode,attr); + } + return error; +} + +//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf) +#else +static int yaffs_statfs(struct super_block *sb, struct statfs *buf) +#endif +{ + yaffs_Device *dev = yaffs_SuperToDevice(sb); + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_statfs\n")); + + yaffs_GrossLock(dev); + + buf->f_type = YAFFS_MAGIC; + buf->f_bsize = sb->s_blocksize; + buf->f_namelen = 255; + buf->f_blocks = (dev->endBlock - dev->startBlock + 1) * YAFFS_CHUNKS_PER_BLOCK/ + (sb->s_blocksize/YAFFS_BYTES_PER_CHUNK); + buf->f_files = 0; + buf->f_ffree = 0; + buf->f_bfree = yaffs_GetNumberOfFreeChunks(dev)/ + (sb->s_blocksize/YAFFS_BYTES_PER_CHUNK); + buf->f_bavail = buf->f_bfree; + + yaffs_GrossUnlock(dev); + return 0; +} + +static void yaffs_read_inode (struct inode *inode) +{ + // NB This is called as a side effect of other functions and + // thus gross locking should always be in place already. + + yaffs_Object *obj ; + yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb); + + T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_read_inode for %d\n",(int)inode->i_ino)); + + obj = yaffs_FindObjectByNumber(dev,inode->i_ino); + + yaffs_FillInodeFromObject(inode,obj); + +} + + + +// Todo +// Currently we only can report a single partition. Need to use lists here +static yaffs_Device *yaffs_dev; +static yaffs_Device *yaffsram_dev; + + + +static void yaffs_put_super(struct super_block *sb) +{ + yaffs_Device *dev = yaffs_SuperToDevice(sb); + + yaffs_GrossLock(dev); + if(dev->putSuperFunc) + { + dev->putSuperFunc(sb); + } + yaffs_Deinitialise(dev); + yaffs_GrossUnlock(dev); + + if(dev == yaffs_dev) yaffs_dev = NULL; + if(dev == yaffsram_dev) yaffsram_dev = NULL; + + kfree(dev); +} + + +#ifdef CONFIG_YAFFS_MTD_ENABLED + +static void yaffs_MTDPutSuper(struct super_block *sb) +{ + + struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice; + + if(mtd->sync) + { + mtd->sync(mtd); + } + + put_mtd_device(mtd); +} + +#endif + + +static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam, struct super_block * sb, void * data, int silent) +{ + int nBlocks; + struct inode * inode = NULL; + struct dentry * root; + yaffs_Device *dev; + int err; + + sb->s_magic = YAFFS_MAGIC; + sb->s_op = &yaffs_super_ops; + + if(!sb) + printk(KERN_INFO"yaffs: sb is NULL\n"); + else if(!sb->s_dev) + printk(KERN_INFO"yaffs: sb->s_dev is NULL\n"); + else if(! kdevname(sb->s_dev)) + printk(KERN_INFO"yaffs: kdevname is NULL\n"); + else + printk(KERN_INFO"yaffs: dev is %d name is \"%s\"\n", sb->s_dev, kdevname(sb->s_dev)); + + + +#ifdef CONFIG_YAFFS_USE_CHUNK_SIZE + sb->s_blocksize = YAFFS_BYTES_PER_CHUNK; + sb->s_blocksize_bits = YAFFS_CHUNK_SIZE_SHIFT; +#else + sb->s_blocksize = PAGE_CACHE_SIZE; + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; +#endif + T(YAFFS_TRACE_OS,("yaffs_read_super: Using yaffs%d\n",yaffsVersion)); + T(YAFFS_TRACE_OS,("yaffs_read_super: %s block size %d\n", useRam ? "RAM" : "MTD",(int)(sb->s_blocksize))); + +#ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY + T(YAFFS_TRACE_OS,("yaffs: Write verification disabled. All guarantees null and void\n")); +#endif + + + + if(useRam) + { + +#ifdef CONFIG_YAFFS_RAM_ENABLED + // Set the yaffs_Device up for ram emulation + + sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL); + if(!dev) + { + // Deep shit could not allocate device structure + T(YAFFS_TRACE_OS,("yaffs_read_super: Failed trying to allocate yaffs_Device.\n")); + return NULL; + } + + memset(dev,0,sizeof(yaffs_Device)); + dev->genericDevice = NULL; // Not used for RAM emulation. + + nBlocks = YAFFS_RAM_EMULATION_SIZE / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK); + dev->startBlock = 1; // Don't use block 0 + dev->endBlock = nBlocks - 1; + dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; + dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK; + dev->nReservedBlocks = 5; + + if(yaffsVersion == 2) + { + dev->writeChunkWithTagsToNAND = nandemul2k_WriteChunkWithTagsToNAND; + dev->readChunkWithTagsFromNAND = nandemul2k_ReadChunkWithTagsFromNAND; + dev->markNANDBlockBad = nandemul2k_MarkNANDBlockBad; + dev->queryNANDBlock = nandemul2k_QueryNANDBlock; + dev->eraseBlockInNAND = nandemul2k_EraseBlockInNAND; + dev->initialiseNAND = nandemul2k_InitialiseNAND; + dev->isYaffs2 = 1; + dev->nChunksPerBlock = nandemul2k_GetChunksPerBlock(); + dev->nBytesPerChunk = nandemul2k_GetBytesPerChunk();; + nBlocks = nandemul2k_GetNumberOfBlocks(); + dev->startBlock = 1; // Don't use block 0 + dev->endBlock = nBlocks - 1; + } + else + { + dev->writeChunkToNAND = nandemul_WriteChunkToNAND; + dev->readChunkFromNAND = nandemul_ReadChunkFromNAND; + dev->eraseBlockInNAND = nandemul_EraseBlockInNAND; + dev->initialiseNAND = nandemul_InitialiseNAND; + dev->isYaffs2 = 0; + } + + yaffsram_dev = dev; + +#endif + + } + else + { +#ifdef CONFIG_YAFFS_MTD_ENABLED + struct mtd_info *mtd; + + T(YAFFS_TRACE_ALWAYS,("yaffs: Attempting MTD mount on %u.%u, \"%s\"\n", + MAJOR(sb->s_dev),MINOR(sb->s_dev),kdevname(sb->s_dev))); + + // Check it's an mtd device..... + if(MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) + { + return NULL; // This isn't an mtd device + } + + // Get the device + mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); + if (!mtd) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device #%u doesn't appear to exist\n", MINOR(sb->s_dev))); + return NULL; + } + + // Check it's NAND + if(mtd->type != MTD_NANDFLASH) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device is not NAND it's type %d\n", mtd->type)); + return NULL; + } + + T(YAFFS_TRACE_OS,(" erase %x\n",mtd->erase)); + T(YAFFS_TRACE_OS,(" read %x\n",mtd->read)); + T(YAFFS_TRACE_OS,(" write %x\n",mtd->write)); + T(YAFFS_TRACE_OS,(" readoob %x\n",mtd->read_oob)); + T(YAFFS_TRACE_OS,(" writeoob %x\n",mtd->write_oob)); + T(YAFFS_TRACE_OS,(" block_isbad %x\n",mtd->block_isbad)); + T(YAFFS_TRACE_OS,(" block_markbad %x\n",mtd->block_markbad)); + T(YAFFS_TRACE_OS,(" oobblock %d\n",mtd->oobblock)); + T(YAFFS_TRACE_OS,(" oobsize %d\n",mtd->oobsize)); + T(YAFFS_TRACE_OS,(" erasesize %d\n",mtd->erasesize)); + T(YAFFS_TRACE_OS,(" size %d\n",mtd->size)); + + if(yaffsVersion == 2) + { + // Check for version 2 style functions + if(!mtd->erase || + !mtd->block_isbad || + !mtd->block_markbad || + !mtd->read || + !mtd->write || +#ifndef CONFIG_YAFFS_USE_OLD_MTD + !mtd->write_ecc || + !mtd->read_ecc || +#endif + !mtd->read_oob || + !mtd->write_oob ) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));; + return NULL; + } + + if(mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE || + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n")); + return NULL; + } } + else + { + // Check for V1 style functions + if(!mtd->erase || + !mtd->read || + !mtd->write || +#ifndef CONFIG_YAFFS_USE_OLD_MTD + !mtd->write_ecc || + !mtd->read_ecc || +#endif + !mtd->read_oob || + !mtd->write_oob ) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));; + return NULL; + } + + if(mtd->oobblock != YAFFS_BYTES_PER_CHUNK || + mtd->oobsize != YAFFS_BYTES_PER_SPARE) + { + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n")); + return NULL; + } + } + + + // OK, so if we got here, we have an MTD that's NAND and looks + // like it has the right capabilities + // Set the yaffs_Device up for mtd + +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) + sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL); +#else + sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL); +#endif + if(!dev) + { + // Deep shit could not allocate device structure + T(YAFFS_TRACE_ALWAYS,("yaffs_read_super: Failed trying to allocate yaffs_Device. \n")); + return NULL; + } + + memset(dev,0,sizeof(yaffs_Device)); + dev->genericDevice = mtd; + + // Set up the memory size parameters.... + + nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK); + dev->startBlock = 1; // Don't use block 0 + dev->endBlock = nBlocks - 1; + dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; + dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK; + dev->nReservedBlocks = 5; + dev->nShortOpCaches = 10; // Enable short op caching + + + // ... and the functions. + if(yaffsVersion == 2) + { + dev->writeChunkWithTagsToNAND = nandmtd2_WriteChunkWithTagsToNAND; + dev->readChunkWithTagsFromNAND = nandmtd2_ReadChunkWithTagsFromNAND; + dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; + dev->queryNANDBlock = nandmtd2_QueryNANDBlock; + dev->spareBuffer = YMALLOC(mtd->oobsize); + dev->isYaffs2 = 1; + dev->nBytesPerChunk = mtd->oobblock; + dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock; + nBlocks = mtd->size / mtd->erasesize; + dev->startBlock = 1; // Don't use block 0 + dev->endBlock = nBlocks - 1; + } + else + { + dev->writeChunkToNAND = nandmtd_WriteChunkToNAND; + dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND; + dev->isYaffs2 = 0; + } + // ... and common functions + dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND; + dev->initialiseNAND = nandmtd_InitialiseNAND; + + dev->putSuperFunc = yaffs_MTDPutSuper; + +#ifdef CONFIG_YAFFS_USE_NANDECC + dev->useNANDECC = 1; +#endif + + yaffs_dev = dev; + +#endif + } + + init_MUTEX(&dev->grossLock); + + + yaffs_GrossLock(dev); + + err = yaffs_GutsInitialise(dev); + + T(YAFFS_TRACE_OS,("yaffs_read_super: guts initialised %s\n", (err == YAFFS_OK) ? "OK" : "FAILED")); + + // Create root inode + if(err == YAFFS_OK) + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,yaffs_Root(dev)); + + yaffs_GrossUnlock(dev); + + if (!inode) + return NULL; + +// added NCB + inode->i_op = & yaffs_dir_inode_operations; + inode->i_fop = & yaffs_dir_operations; + + T(YAFFS_TRACE_OS,("yaffs_read_super: got root inode\n")); + + + root = d_alloc_root(inode); + + T(YAFFS_TRACE_OS,("yaffs_read_super: d_alloc_root done\n")); + + if (!root) { + iput(inode); + return NULL; + } + sb->s_root = root; + + T(YAFFS_TRACE_OS,("yaffs_read_super: done\n")); + return sb; +} + + +static int yaffs_internal_read_super_ram(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(1,1,sb,data,silent) ? 0 : -1; +} +static int yaffs_internal_read_super_mtd(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(1,0,sb,data,silent) ? 0 : -1; +} + +static int yaffs2_internal_read_super_ram(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(2,1,sb,data,silent) ? 0 : -1; +} +static int yaffs2_internal_read_super_mtd(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(2,0,sb,data,silent) ? 0 : -1; +} + + + +#ifdef CONFIG_YAFFS_MTD_ENABLED +//#if defined(CONFIG_KERNEL_2_5) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static struct super_block *yaffs_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data) +{ + + return get_sb_bdev(fs, flags, dev_name, data, yaffs_internal_read_super_mtd); +} + +/* changes NCB 2.5.70 */ +//static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); +static struct file_system_type yaffs_fs_type = { + .owner = THIS_MODULE, + .name = "yaffs", + .get_sb = yaffs_read_super, +// .kill_sb = kill_block_super, + .kill_sb = kill_litter_super, + .fs_flags = FS_REQUIRES_DEV, +}; +#else +static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(1,0,sb,data,silent); +} + +static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); +#endif + +#endif // CONFIG_YAFFS_MTD_ENABLED + +#ifdef CONFIG_YAFFS2_MTD_ENABLED + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static struct super_block *yaffs2_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data) +{ + + return get_sb_bdev(fs, flags, dev_name, data, yaffs2_internal_read_super_mtd); +} + +/* changes NCB 2.5.70 */ +//static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); +static struct file_system_type yaffs2_fs_type = { + .owner = THIS_MODULE, + .name = "yaffs2", + .get_sb = yaffs2_read_super, +// .kill_sb = kill_block_super, + .kill_sb = kill_litter_super, + .fs_flags = FS_REQUIRES_DEV, +}; +#else +static struct super_block *yaffs2_read_super(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(2,0,sb,data,silent); +} + +static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_DEV); +#endif + +#endif // CONFIG_YAFFS2_MTD_ENABLED + + +#ifdef CONFIG_YAFFS_RAM_ENABLED + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static struct super_block *yaffs_ram_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data) +{ + + return get_sb_bdev(fs, flags, dev_name, data, yaffs_internal_read_super_ram); +} + + +static struct file_system_type yaffs_ram_fs_type = { + .owner = THIS_MODULE, + .name = "yaffsram", + .get_sb = yaffs_ram_read_super, +// .kill_sb = kill_block_super, + .kill_sb = kill_litter_super, + .fs_flags = FS_SINGLE, +}; +#else +static struct super_block *yaffs_ram_read_super(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(1,1,sb,data,silent); +} + +static DECLARE_FSTYPE(yaffs_ram_fs_type, "yaffsram", yaffs_ram_read_super, FS_SINGLE); +#endif + +#endif // CONFIG_YAFFS_RAM_ENABLED + +#ifdef CONFIG_YAFFS2_RAM_ENABLED + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +static struct super_block *yaffs2_ram_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data) +{ + + return get_sb_bdev(fs, flags, dev_name, data, yaffs2_internal_read_super_ram); +} + + +static struct file_system_type yaffs2_ram_fs_type = { + .owner = THIS_MODULE, + .name = "yaffs2ram", + .get_sb = yaffs2_ram_read_super, +// .kill_sb = kill_block_super, + .kill_sb = kill_litter_super, + .fs_flags = FS_SINGLE, +}; +#else +static struct super_block *yaffs2_ram_read_super(struct super_block * sb, void * data, int silent) +{ + return yaffs_internal_read_super(2,1,sb,data,silent); +} + +static DECLARE_FSTYPE(yaffs2_ram_fs_type, "yaffs2ram", yaffs2_ram_read_super, FS_SINGLE); +#endif + +#endif // CONFIG_YAFFS2_RAM_ENABLED + + + +static struct proc_dir_entry *my_proc_entry; +static struct proc_dir_entry *my_proc_ram_write_entry; + +static char * yaffs_dump_dev(char *buf,yaffs_Device *dev,char *name) +{ + buf +=sprintf(buf,"\nDevice %s\n",name); + buf +=sprintf(buf,"startBlock......... %d\n",dev->startBlock); + buf +=sprintf(buf,"endBlock........... %d\n",dev->endBlock); + buf +=sprintf(buf,"chunkGroupBits..... %d\n",dev->chunkGroupBits); + buf +=sprintf(buf,"chunkGroupSize..... %d\n",dev->chunkGroupSize); + buf +=sprintf(buf,"nErasedBlocks...... %d\n",dev->nErasedBlocks); + buf +=sprintf(buf,"nTnodesCreated..... %d\n",dev->nTnodesCreated); + buf +=sprintf(buf,"nFreeTnodes........ %d\n",dev->nFreeTnodes); + buf +=sprintf(buf,"nObjectsCreated.... %d\n",dev->nObjectsCreated); + buf +=sprintf(buf,"nFreeObjects....... %d\n",dev->nFreeObjects); + buf +=sprintf(buf,"nFreeChunks........ %d\n",dev->nFreeChunks); + buf +=sprintf(buf,"nPageWrites........ %d\n",dev->nPageWrites); + buf +=sprintf(buf,"nPageReads......... %d\n",dev->nPageReads); + buf +=sprintf(buf,"nBlockErasures..... %d\n",dev->nBlockErasures); + buf +=sprintf(buf,"nGCCopies.......... %d\n",dev->nGCCopies); + buf +=sprintf(buf,"garbageCollections. %d\n",dev->garbageCollections); + buf +=sprintf(buf,"passiveGCs......... %d\n",dev->passiveGarbageCollections); + buf +=sprintf(buf,"nRetriedWrites..... %d\n",dev->nRetriedWrites); + buf +=sprintf(buf,"nRetireBlocks...... %d\n",dev->nRetiredBlocks); + buf +=sprintf(buf,"eccFixed........... %d\n",dev->eccFixed); + buf +=sprintf(buf,"eccUnfixed......... %d\n",dev->eccUnfixed); + buf +=sprintf(buf,"tagsEccFixed....... %d\n",dev->tagsEccFixed); + buf +=sprintf(buf,"tagsEccUnfixed..... %d\n",dev->tagsEccUnfixed); + buf +=sprintf(buf,"cacheHits.......... %d\n",dev->cacheHits); + buf +=sprintf(buf,"nDeletedFiles...... %d\n",dev->nDeletedFiles); + buf +=sprintf(buf,"nUnlinkedFiles..... %d\n",dev->nUnlinkedFiles); + buf +=sprintf(buf,"nBackgroudDeletions %d\n",dev->nBackgroundDeletions); + buf +=sprintf(buf,"useNANDECC......... %d\n",dev->useNANDECC); + buf +=sprintf(buf,"isYaffs2........... %d\n",dev->isYaffs2); + + + return buf; +} + +static int yaffs_proc_read( + char *page, + char **start, + off_t offset, + int count, + int *eof, + void *data + ) +{ + + char my_buffer[3000]; + char *buf; + buf = my_buffer; + + if (offset > 0) return 0; + + /* Fill the buffer and get its length */ + buf +=sprintf(buf,"YAFFS built:"__DATE__ " "__TIME__"\n%s\n%s\n", yaffs_fs_c_version,yaffs_guts_c_version); + + if(yaffs_dev) buf = yaffs_dump_dev(buf,yaffs_dev,"yaffs"); + if(yaffsram_dev) buf = yaffs_dump_dev(buf,yaffsram_dev,"yaffsram"); + + + strcpy(page,my_buffer); + return strlen(my_buffer); +} + + +static int yaffs_proc_ram_write( + char *page, + char **start, + off_t offset, + int count, + int *eof, + void *data + ) +{ + + printk(KERN_DEBUG "yaffs write size %d\n",count); + return count; +} + + + +// Stuff to handle installation of file systems +struct file_system_to_install +{ + struct file_system_type *fst; + int installed; +}; + +static struct file_system_to_install fs_to_install[] = +{ +#ifdef CONFIG_YAFFS_RAM_ENABLED + { &yaffs_ram_fs_type, 0}, +#endif +#ifdef CONFIG_YAFFS2_RAM_ENABLED + { &yaffs2_ram_fs_type,0}, +#endif +#ifdef CONFIG_YAFFS_MTD_ENABLED + { &yaffs_fs_type,0}, +#endif +#ifdef CONFIG_YAFFS2_MTD_ENABLED + { &yaffs2_fs_type,0}, +#endif + { NULL,0} +}; + +static int __init init_yaffs_fs(void) +{ + int error = 0; + struct file_system_to_install *fsinst; + + yaffs_dev = yaffsram_dev = NULL; + + T(YAFFS_TRACE_ALWAYS,("yaffs " __DATE__ " " __TIME__ " Installing. \n")); + + + + /* Install the proc_fs entry */ + my_proc_entry = create_proc_read_entry("yaffs", + S_IRUGO | S_IFREG, + &proc_root, + yaffs_proc_read, + NULL); + if(!my_proc_entry) + { + return -ENOMEM; + } + + + + // Now add the file system entries + + fsinst = fs_to_install; + + while(fsinst->fst && !error) + { + error = register_filesystem(fsinst->fst); + if(!error) + { + fsinst->installed = 1; + } + fsinst++; + } + + // Any errors? uninstall + if(error) + { + fsinst = fs_to_install; + + while(fsinst->fst) + { + if(fsinst->installed) + { + unregister_filesystem(fsinst->fst); + fsinst->installed = 0; + } + fsinst++; + } + } + + return error; +} + +static void __exit exit_yaffs_fs(void) +{ + + struct file_system_to_install *fsinst; + + T(YAFFS_TRACE_ALWAYS,("yaffs " __DATE__ " " __TIME__ " removing. \n")); + + remove_proc_entry("yaffs",&proc_root); + + fsinst = fs_to_install; + + while(fsinst->fst) + { + if(fsinst->installed) + { + unregister_filesystem(fsinst->fst); + fsinst->installed = 0; + } + fsinst++; + } + +} + +module_init(init_yaffs_fs) +module_exit(exit_yaffs_fs) + +MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); +MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002,2003,2004"); +MODULE_LICENSE("GPL"); + diff --git a/yaffs_guts.c b/yaffs_guts.c index 340c736..2f899f3 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -1,19 +1,20 @@ + /* - * YAFFS: Yet another FFS. A NAND-flash specific file system. - * yaffs_guts.c The main guts of YAFFS + * YAFFS: Yet another FFS. A NAND-flash specific file system. * * Copyright (C) 2002 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning * + * 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. * */ //yaffs_guts.c -const char *yaffs_guts_c_version="$Id: yaffs_guts.c,v 1.3 2004-11-22 03:22:25 charles Exp $"; +const char *yaffs_guts_c_version="$Id: yaffs_guts.c,v 1.4 2004-12-17 04:39:04 charles Exp $"; #include "yportenv.h" @@ -475,7 +476,8 @@ int yaffs_CheckFF(__u8 *buffer,int nBytes) //Horrible, slow implementation while(nBytes--) { - if(*buffer != 0xFF) return 0; + if(*buffer != 0xFF) return 0; + buffer++; } return 1; } @@ -4525,7 +4527,7 @@ static int yaffs_Scan(yaffs_Device *dev) yaffs_BlockIndex *blockIndex = NULL; - T(YAFFS_TRACE_SCAN,(TSTR("yaffs_Scan starts..." TENDSTR))); + T(YAFFS_TRACE_SCAN,(TSTR("yaffs_Scan starts startblk %d endblk %d..." TENDSTR),dev->startBlock,dev->endBlock)); chunkData = yaffs_GetTempBuffer(dev,__LINE__); @@ -4550,6 +4552,8 @@ static int yaffs_Scan(yaffs_Device *dev) bi->blockState = state; bi->sequenceNumber = sequenceNumber; + + T(YAFFS_TRACE_SCAN_DEBUG,(TSTR("Block scanning block %d state %d seq %d" TENDSTR),blk,state,sequenceNumber)); if(state == YAFFS_BLOCK_STATE_DEAD) { @@ -4557,6 +4561,7 @@ static int yaffs_Scan(yaffs_Device *dev) } else if(state == YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_SCAN_DEBUG,(TSTR("Block empty " TENDSTR))); dev->nErasedBlocks++; dev->nFreeChunks += dev->nChunksPerBlock; } @@ -4612,6 +4617,7 @@ static int yaffs_Scan(yaffs_Device *dev) { startIterator = 0; endIterator = nBlocksToScan-1; + T(YAFFS_TRACE_SCAN_DEBUG,(TSTR("%d blocks to be scanned" TENDSTR),nBlocksToScan)); } else { @@ -5697,4 +5703,3 @@ void yaffs_GutsTest(yaffs_Device *dev) #endif - diff --git a/yaffs_guts.h b/yaffs_guts.h index 506ecd6..cfcd16f 100644 --- a/yaffs_guts.h +++ b/yaffs_guts.h @@ -14,7 +14,7 @@ * * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. * - * $Id: yaffs_guts.h,v 1.2 2004-11-16 02:36:15 charles Exp $ + * $Id: yaffs_guts.h,v 1.3 2004-12-17 04:39:04 charles Exp $ */ #ifndef __YAFFS_GUTS_H__ @@ -50,6 +50,9 @@ #define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) #endif +#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 +#define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 + #define YAFFS_MAX_CHUNK_ID 0x000FFFFF #define YAFFS_UNUSED_OBJECT_ID 0x0003FFFF @@ -532,9 +535,7 @@ struct yaffs_DeviceStruct struct semaphore sem;// Semaphore for waiting on erasure. struct semaphore grossLock; // Gross locking semaphore - -#endif -#ifdef __KERNEL__ + __u8 * spareBuffer; // For mtdif2 use. Don't know the size of the buffer at compile time so we have to allocate it. void (*putSuperFunc)(struct super_block *sb); #endif diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c new file mode 100644 index 0000000..2dfc705 --- /dev/null +++ b/yaffs_mtdif.c @@ -0,0 +1,163 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_mtdif.c NAND mtd wrapper functions. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + */ + +const char *yaffs_mtdif_c_version = "$Id: yaffs_mtdif.c,v 1.1 2004-12-17 04:39:04 charles Exp $"; + +#ifdef CONFIG_YAFFS_MTD_ENABLED + +#include "yportenv.h" + +#include "yaffs_mtdif.h" + +#include "linux/mtd/mtd.h" +#include "linux/types.h" +#include "linux/time.h" + +#ifndef CONFIG_YAFFS_USE_OLD_MTD +#include "linux/mtd/nand.h" +#endif + +struct nand_oobinfo yaffs_oobinfo = { + useecc: 1, + eccpos: {8, 9, 10, 13, 14, 15} +}; + +struct nand_oobinfo yaffs_noeccinfo = { + useecc: 0, +}; + + +int nandmtd_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + size_t dummy; + int retval = 0; + + loff_t addr = ((loff_t)chunkInNAND) * dev->nBytesPerChunk; + + __u8 *spareAsBytes = (__u8 *)spare; + +#ifndef CONFIG_YAFFS_USE_OLD_MTD + if(data && spare) + { + if(dev->useNANDECC) + mtd->write_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,spareAsBytes,&yaffs_oobinfo); + else + mtd->write_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,spareAsBytes,&yaffs_noeccinfo); + } + else + { +#endif + if(data) + retval = mtd->write(mtd,addr,dev->nBytesPerChunk,&dummy,data); + if(spare) + retval = mtd->write_oob(mtd,addr,YAFFS_BYTES_PER_SPARE,&dummy,spareAsBytes); +#ifndef CONFIG_YAFFS_USE_OLD_MTD + } +#endif + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + size_t dummy; + int retval = 0; + + loff_t addr = ((loff_t)chunkInNAND) * dev->nBytesPerChunk; + + __u8 *spareAsBytes = (__u8 *)spare; + +#ifndef CONFIG_YAFFS_USE_OLD_MTD + if(data && spare) + { + if(dev->useNANDECC) + { // Careful, this call adds 2 ints to the end of the spare data. Calling function should + // allocate enough memory for spare, i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. + retval = mtd->read_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,spareAsBytes,&yaffs_oobinfo); + } + else + { + retval = mtd->read_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,spareAsBytes,&yaffs_noeccinfo); + } + } + else + { +#endif + if(data) + retval = mtd->read(mtd,addr,dev->nBytesPerChunk,&dummy,data); + if(spare) + retval = mtd->read_oob(mtd,addr,YAFFS_BYTES_PER_SPARE,&dummy,spareAsBytes); +#ifndef CONFIG_YAFFS_USE_OLD_MTD + } +#endif + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +// Callback not needed for NAND +#if 0 +static void nandmtd_EraseCallback(struct erase_info *ei) +{ + yaffs_Device *dev = (yaffs_Device *)ei->priv; + up(&dev->sem); +} +#endif + + +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + __u32 addr = ((loff_t) blockNumber) * dev->nBytesPerChunk * dev->nChunksPerBlock; + struct erase_info ei; + int retval = 0; + + ei.mtd = mtd; + ei.addr = addr; + ei.len = dev->nBytesPerChunk * dev->nChunksPerBlock; + ei.time = 1000; + ei.retries = 2; + ei.callback = NULL; + ei.priv = (u_long)dev; + + // Todo finish off the ei if required + + sema_init(&dev->sem,0); + + retval = mtd->erase(mtd,&ei); + + //No need for callback + // down(&dev->sem); // Wait for the erasure to complete + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd_InitialiseNAND(yaffs_Device *dev) +{ + return YAFFS_OK; +} + +#endif // CONFIG_YAFFS_MTD_ENABLED + diff --git a/yaffs_mtdif.h b/yaffs_mtdif.h new file mode 100644 index 0000000..2e99813 --- /dev/null +++ b/yaffs_mtdif.h @@ -0,0 +1,33 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_mtdif.h NAND mtd interface wrappers + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + * + * $Id: yaffs_mtdif.h,v 1.1 2004-12-17 04:39:04 charles Exp $ + */ + +#ifndef __YAFFS_MTDIF_H__ +#define __YAFFS_MTDIF_H__ + +#include "yaffs_guts.h" + +int nandmtd_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare); +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); +int nandmtd_InitialiseNAND(yaffs_Device *dev); +#endif + + + + diff --git a/yaffs_mtdif2.c b/yaffs_mtdif2.c new file mode 100644 index 0000000..9ddf799 --- /dev/null +++ b/yaffs_mtdif2.c @@ -0,0 +1,184 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_mtdif.c NAND mtd wrapper functions. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + */ + +// mtd interface for YAFFS2 + +const char *yaffs_mtdif2_c_version = "$Id: yaffs_mtdif2.c,v 1.1 2004-12-17 04:39:04 charles Exp $"; + +#ifdef CONFIG_YAFFS_MTD_ENABLED + +#include "yportenv.h" + +#include "yaffs_mtdif2.h" + +#include "linux/mtd/mtd.h" +#include "linux/types.h" +#include "linux/time.h" + +#include "yaffs_packedtags2.h" + + + + +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + size_t dummy; + int retval = 0; + + + loff_t addr = ((loff_t)chunkInNAND) * dev->nBytesPerChunk; + + yaffs_PackedTags2 pt; + + T(YAFFS_TRACE_MTD,(TSTR("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %08x tags %08x" TENDSTR),chunkInNAND,data,tags)); + + if(tags) + { + yaffs_PackTags2(&pt,tags); + } + +#ifndef CONFIG_YAFFS_USE_OLD_MTD + if(data && tags) + { + if(dev->useNANDECC) + retval = mtd->write_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,(__u8 *)&pt,NULL); + else + retval = mtd->write_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,(__u8 *)&pt,NULL); + } + else + { +#endif + if(data) + retval = mtd->write(mtd,addr,dev->nBytesPerChunk,&dummy,data); + if(tags) + retval = mtd->write_oob(mtd,addr,mtd->oobsize,&dummy,(__u8 *)&pt); + +#ifndef CONFIG_YAFFS_USE_OLD_MTD + } +#endif + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + size_t dummy; + int retval = 0; + + + loff_t addr = ((loff_t)chunkInNAND) * dev->nBytesPerChunk; + + yaffs_PackedTags2 pt; + + T(YAFFS_TRACE_MTD,(TSTR("nandmtd2_ReadChunkWithTagsToNAND chunk %d data %08x tags %08x" TENDSTR),chunkInNAND,data,tags)); + +#ifndef CONFIG_YAFFS_USE_OLD_MTD + if(data && tags) + { + if(dev->useNANDECC) + { + retval = mtd->read_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,dev->spareBuffer,NULL); + } + else + { + retval = mtd->read_ecc(mtd,addr,dev->nBytesPerChunk,&dummy,data,dev->spareBuffer,NULL); + } + } + else + { +#endif + if(data) + retval = mtd->read(mtd,addr,dev->nBytesPerChunk,&dummy,data); + if(tags) + retval = mtd->read_oob(mtd,addr,mtd->oobsize,&dummy,dev->spareBuffer); +#ifndef CONFIG_YAFFS_USE_OLD_MTD + } +#endif + + memcpy(&pt,dev->spareBuffer,sizeof(pt)); + + if(tags) + yaffs_UnpackTags2(tags,&pt); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + int retval; + T(YAFFS_TRACE_MTD,(TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR),blockNo)); + + + retval = mtd->block_markbad(mtd,blockNo); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; + +} + +int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber) +{ + struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + int retval; + + T(YAFFS_TRACE_MTD,(TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR),blockNo)); + retval = mtd->block_isbad(mtd,blockNo); + + if(retval) + { + T(YAFFS_TRACE_MTD,(TSTR("block is bad" TENDSTR))); + + *state = YAFFS_BLOCK_STATE_DEAD; + *sequenceNumber = 0; + } + else + { + yaffs_ExtendedTags t; + nandmtd2_ReadChunkWithTagsFromNAND(dev,blockNo * dev->nChunksPerBlock,NULL, &t); + + if(t.chunkUsed) + { + *sequenceNumber = t.sequenceNumber; + *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + } + else + { + *sequenceNumber = 0; + *state = YAFFS_BLOCK_STATE_EMPTY; + } + } + T(YAFFS_TRACE_MTD,(TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber,*state)); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +#endif + + + diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h new file mode 100644 index 0000000..5b308ee --- /dev/null +++ b/yaffs_mtdif2.h @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_mtdif.c NAND mtd wrapper functions. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + */ + + +#ifndef __YAFFS_MTDIF2_H__ +#define __YAFFS_MTDIF2_H__ + + +#include "yaffs_guts.h" +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags); +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); +int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); + +#endif diff --git a/yaffs_nandemul.h b/yaffs_nandemul.h new file mode 100644 index 0000000..8503331 --- /dev/null +++ b/yaffs_nandemul.h @@ -0,0 +1,38 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + * + * yaffs_nandemul.h: Interface to emulated NAND functions + * + * $Id: yaffs_nandemul.h,v 1.1 2004-12-17 04:39:04 charles Exp $ + */ + +#ifndef __YAFFS_NANDEMUL_H__ +#define __YAFFS_NANDEMUL_H__ + +#include "yaffs_guts.h" + + +/* WriteChunkToNAND and ReadChunkFromNAND are used with two pointers. + * If either of these pointers are null, then that field will not be + * transferred. + */ + +int nandemul_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_Spare *spare); +int nandemul_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); +int nandemul_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND); +int nandemul_InitialiseNAND(struct yaffs_DeviceStruct *dev); + +#endif + diff --git a/yaffs_nandemul2k.h b/yaffs_nandemul2k.h new file mode 100644 index 0000000..9778b86 --- /dev/null +++ b/yaffs_nandemul2k.h @@ -0,0 +1,38 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + * + * yaffs_nandemul2k.h: Interface to emulated NAND functions (2k page size) + * + * $Id: yaffs_nandemul2k.h,v 1.1 2004-12-17 04:39:04 charles Exp $ + */ + +#ifndef __YAFFS_NANDEMUL2K_H__ +#define __YAFFS_NANDEMUL2K_H__ + +#include "yaffs_guts.h" + + +int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, const __u8 *data, yaffs_ExtendedTags *tags); +int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); +int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); +int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,int blockInNAND); +int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev); +int nandemul2k_GetBytesPerChunk(void); +int nandemul2k_GetChunksPerBlock(void); +int nandemul2k_GetNumberOfBlocks(void); + +#endif + diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c index 018eacf..bab338f 100644 --- a/yaffs_packedtags1.c +++ b/yaffs_packedtags1.c @@ -1,7 +1,7 @@ #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_PackTags1(yaffs_PackedTags1 *pt, yaffs_ExtendedTags *t) +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t) { pt->chunkId = t->chunkId; pt->serialNumber = t->serialNumber; @@ -14,7 +14,7 @@ void yaffs_PackTags1(yaffs_PackedTags1 *pt, yaffs_ExtendedTags *t) } -void yaffs_UnpackTags1(yaffs_ExtendedTags *t, yaffs_PackedTags1 *pt) +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt) { static const __u8 allFF[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,0xff, 0xff, 0xff, 0xff}; diff --git a/yaffs_packedtags1.h b/yaffs_packedtags1.h index 5f67668..0f76615 100644 --- a/yaffs_packedtags1.h +++ b/yaffs_packedtags1.h @@ -21,8 +21,8 @@ typedef struct -void yaffs_PackTags1(yaffs_PackedTags1 *pt, yaffs_ExtendedTags *t); -void yaffs_UnpackTags1(yaffs_ExtendedTags *t, yaffs_PackedTags1 *pt); +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t); +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt); #endif diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c index f734882..97668dc 100644 --- a/yaffs_packedtags2.c +++ b/yaffs_packedtags2.c @@ -2,19 +2,33 @@ #include "yportenv.h" +static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt) +{ + T(YAFFS_TRACE_MTD,(TSTR("packed tags obj %d chunk %d byte %d seq %d"TENDSTR),pt->t.objectId,pt->t.chunkId,pt->t.byteCount,pt->t.sequenceNumber)); +} + +static void yaffs_DumpTags2(const yaffs_ExtendedTags *t) +{ + T(YAFFS_TRACE_MTD,(TSTR("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d"TENDSTR), + t->eccResult, t->blockBad, t->chunkUsed, t->objectId, t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber, t->sequenceNumber)); + +} -void yaffs_PackTags2(yaffs_PackedTags2 *pt, yaffs_ExtendedTags *t) +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t) { pt->t.chunkId = t->chunkId; pt->t.sequenceNumber = t->sequenceNumber; pt->t.byteCount = t->byteCount; pt->t.objectId = t->objectId; + yaffs_DumpPackedTags2(pt); + yaffs_DumpTags2(t); + yaffs_ECCCalculateOther((unsigned char *)&pt->t,sizeof(yaffs_PackedTags2TagsPart),&pt->ecc); } -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt) +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, const yaffs_PackedTags2 *pt) { @@ -38,5 +52,9 @@ void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt) t->serialNumber = 0; t->sequenceNumber = pt->t.sequenceNumber; } + + yaffs_DumpPackedTags2(pt); + yaffs_DumpTags2(t); + } diff --git a/yaffs_packedtags2.h b/yaffs_packedtags2.h index 659e2f6..7eb89d4 100644 --- a/yaffs_packedtags2.h +++ b/yaffs_packedtags2.h @@ -24,8 +24,8 @@ typedef struct } yaffs_PackedTags2; -void yaffs_PackTags2(yaffs_PackedTags2 *pt, yaffs_ExtendedTags *t); -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt); +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t); +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, const yaffs_PackedTags2 *pt); #endif diff --git a/yaffs_ramem.c b/yaffs_ramem.c new file mode 100644 index 0000000..15dbabf --- /dev/null +++ b/yaffs_ramem.c @@ -0,0 +1,312 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_ramem.c NAND emulation on top of a chunk of RAM + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + */ + //yaffs_ramem.c + // Since this creates the RAM block at start up it is pretty useless for testing the scanner. + +const char *yaffs_ramem_c_version = "$Id: yaffs_ramem.c,v 1.1 2004-12-17 04:39:04 charles Exp $"; + +#ifndef __KERNEL__ +#define CONFIG_YAFFS_RAM_ENABLED +#endif + +#ifdef CONFIG_YAFFS_RAM_ENABLED + +#include "yportenv.h" + +#include "yaffs_nandemul.h" +#include "yaffs_guts.h" +#include "yaffsinterface.h" +#include "devextras.h" + + +#define EM_SIZE_IN_MEG 2 + +#define BLOCK_SIZE (32 * 528) +#define BLOCKS_PER_MEG ((1024*1024)/(32 * 512)) +#define FILE_SIZE_IN_BLOCKS (FILE_SIZE_IN_MEG * BLOCKS_PER_MEG) +#define FILE_SIZE_IN_BYTES (FILE_SIZE_IN_BLOCKS * BLOCK_SIZE) + + + +#define DEFAULT_SIZE_IN_MB 2 + +typedef struct +{ + __u8 data[528]; // Data + spare + int count[3]; // The programming count for each area of + // the page (0..255,256..511,512..527 + int empty; // is this empty? +} nandemul_Page; + +typedef struct +{ + nandemul_Page page[32]; // The pages in the block + __u8 damaged; // Is the block damaged? + +} nandemul_Block; + + + +typedef struct +{ + nandemul_Block **block; + int nBlocks; +} nandemul_Device; + +static nandemul_Device ned; + +static int sizeInMB = DEFAULT_SIZE_IN_MB; + + +static void nandemul_yield(int n) +{ +#ifdef __KERNEL__ + if(n > 0) schedule_timeout(n); +#endif + +} + + +static void nandemul_ReallyEraseBlock(int blockNumber) +{ + int i; + + nandemul_Block *theBlock = ned.block[blockNumber]; + + for(i = 0; i < 32; i++) + { + memset(theBlock->page[i].data,0xff,528); + theBlock->page[i].count[0] = 0; + theBlock->page[i].count[1] = 0; + theBlock->page[i].count[2] = 0; + theBlock->page[i].empty = 1; + nandemul_yield(2); + } + +} + + +int nandemul_CalcNBlocks(void) +{ + switch(sizeInMB) + { + case 8: + case 16: + case 32: + case 64: + case 128: + case 256: + case 512: + break; + default: + sizeInMB = DEFAULT_SIZE_IN_MB; + } + return sizeInMB * 64; +} + + + +static int CheckInit(void) +{ + static int initialised = 0; + + int i; + int fail = 0; + int nBlocks; + int nAllocated = 0; + + if(initialised) + { + return YAFFS_OK; + } + + + nBlocks = nandemul_CalcNBlocks(); + + ned.block = YMALLOC(sizeof(nandemul_Block *) * nBlocks); + + if(!ned.block) return 0; + + for(i=0; i damaged = 0; + nAllocated++; + } + } + + if(fail) + { + for(i = 0; i < nAllocated; i++) + { + YFREE(ned.block[i]); + } + YFREE(ned.block); + + T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n", + nAllocated/64,sizeInMB)); + return 0; + } + + ned.nBlocks = nBlocks; + + initialised = 1; + + return 1; +} + +int nandemul_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare) +{ + int blk; + int pg; + int i; + + __u8 *x; + + __u8 *spareAsBytes = (__u8 *)spare; + + + CheckInit(); + + blk = chunkInNAND/32; + pg = chunkInNAND%32; + + + if(data) + { + x = ned.block[blk]->page[pg].data; + + for(i = 0; i < 512; i++) + { + x[i] &=data[i]; + } + + ned.block[blk]->page[pg].count[0]++; + ned.block[blk]->page[pg].count[1]++; + ned.block[blk]->page[pg].empty = 0; + } + + + if(spare) + { + x = &ned.block[blk]->page[pg].data[512]; + + for(i = 0; i < 16; i++) + { + x[i] &=spareAsBytes[i]; + } + ned.block[blk]->page[pg].count[2]++; + } + + if(spare || data) + { + nandemul_yield(1); + } + + return YAFFS_OK; +} + + +int nandemul_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare) +{ + int blk; + int pg; + + + CheckInit(); + + blk = chunkInNAND/32; + pg = chunkInNAND%32; + + + if(data) + { + memcpy(data,ned.block[blk]->page[pg].data,512); + } + + + if(spare) + { + memcpy(spare,&ned.block[blk]->page[pg].data[512],16); + } + + return YAFFS_OK; +} + + +int nandemul_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) +{ + int blk; + int pg; + int i; + + + CheckInit(); + + blk = chunkInNAND/32; + pg = chunkInNAND%32; + + + for(i = 0; i < 528; i++) + { + if(ned.block[blk]->page[pg].data[i] != 0xFF) + { + return YAFFS_FAIL; + } + } + + return YAFFS_OK; + +} + +int nandemul_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +{ + + CheckInit(); + + if(blockNumber < 0 || blockNumber >= ned.nBlocks) + { + T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber)); + } + else if(ned.block[blockNumber]->damaged) + { + T(YAFFS_TRACE_ALWAYS,("Attempt to erase damaged block %d\n",blockNumber)); + } + else + { + nandemul_ReallyEraseBlock(blockNumber); + } + + return YAFFS_OK; +} + +int nandemul_InitialiseNAND(yaffs_Device *dev) +{ + return YAFFS_OK; +} + +#endif //YAFFS_RAM_ENABLED + diff --git a/yaffs_ramem2k.c b/yaffs_ramem2k.c new file mode 100644 index 0000000..2c113db --- /dev/null +++ b/yaffs_ramem2k.c @@ -0,0 +1,360 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * yaffs_ramem.c NAND emulation on top of a chunk of RAM + * + * Copyright (C) 2002 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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. + * + */ + //yaffs_ramem2k.c: RAM emulation in-kernel for 2K pages (YAFFS2) + + +const char *yaffs_ramem2k_c_version = "$Id: yaffs_ramem2k.c,v 1.1 2004-12-17 04:39:04 charles Exp $"; + +#ifndef __KERNEL__ +#define CONFIG_YAFFS_RAM_ENABLED +#endif + +#ifdef CONFIG_YAFFS_RAM_ENABLED + +#include "yportenv.h" + +#include "yaffs_nandemul2k.h" +#include "yaffs_guts.h" +#include "yaffsinterface.h" +#include "devextras.h" +#include "yaffs_packedtags2.h" + + + +#define EM_SIZE_IN_MEG 2 +#define PAGE_DATA_SIZE (2048) +#define PAGE_SPARE_SIZE (64) +#define PAGES_PER_BLOCK (64) + + + +#define EM_SIZE_IN_BYTES (EM_SIZE_IN_MEG * (1<<20)) + +#define PAGE_TOTAL_SIZE (PAGE_DATA_SIZE+PAGE_SPARE_SIZE) + +#define BLOCK_TOTAL_SIZE (PAGES_PER_BLOCK * PAGE_TOTAL_SIZE) + +#define BLOCKS_PER_MEG ((1<<20)/(PAGES_PER_BLOCK * PAGE_DATA_SIZE)) + + +typedef struct +{ + __u8 data[PAGE_TOTAL_SIZE]; // Data + spare + int empty; // is this empty? +} nandemul_Page; + + +typedef struct +{ + nandemul_Page *page[PAGES_PER_BLOCK]; + int damaged; +} nandemul_Block; + + + +typedef struct +{ + nandemul_Block**block; + int nBlocks; +} nandemul_Device; + +static nandemul_Device ned; + +static int sizeInMB = EM_SIZE_IN_MEG; + + +static void nandemul_yield(int n) +{ +#ifdef __KERNEL__ + if(n > 0) schedule_timeout(n); +#endif + +} + + +static void nandemul_ReallyEraseBlock(int blockNumber) +{ + int i; + + nandemul_Block *blk; + + if(blockNumber < 0 || blockNumber >= ned.nBlocks) + { + return; + } + + blk = ned.block[blockNumber]; + + for(i = 0; i < PAGES_PER_BLOCK; i++) + { + memset(blk->page[i],0xff,sizeof(nandemul_Page)); + blk->page[i]->empty = 1; + } + nandemul_yield(2); +} + + +static int nandemul2k_CalcNBlocks(void) +{ + return EM_SIZE_IN_MEG * BLOCKS_PER_MEG; +} + + + +static int CheckInit(void) +{ + static int initialised = 0; + + int i,j; + + int fail = 0; + int nBlocks; + + int nAllocated = 0; + + if(initialised) + { + return YAFFS_OK; + } + + + ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks(); + + + ned.block = YMALLOC(sizeof(nandemul_Block*) * nBlocks ); + + if(!ned.block) return YAFFS_FAIL; + + + + + + for(i=fail=0; i page[j] = YMALLOC(sizeof(nandemul_Page))) == 0) + { + fail = 1; + } + } + nandemul_ReallyEraseBlock(i); + ned.block[i]->damaged = 0; + nAllocated++; + } + } + + if(fail) + { + //Todo thump pages + + for(i = 0; i < nAllocated; i++) + { + YFREE(ned.block[i]); + } + YFREE(ned.block); + + T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n", + nAllocated/64,sizeInMB)); + return 0; + } + + ned.nBlocks = nBlocks; + + initialised = 1; + + return 1; +} + +int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags) +{ + int blk; + int pg; + int i; + + __u8 *x; + + + blk = chunkInNAND/PAGES_PER_BLOCK; + pg = chunkInNAND%PAGES_PER_BLOCK; + + + if(data) + { + x = ned.block[blk]->page[pg]->data; + + for(i = 0; i < PAGE_DATA_SIZE; i++) + { + x[i] &=data[i]; + } + + ned.block[blk]->page[pg]->empty = 0; + } + + + if(tags) + { + x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; + + yaffs_PackTags2((yaffs_PackedTags2 *)x,tags); + + } + + if(tags || data) + { + nandemul_yield(1); + } + + return YAFFS_OK; +} + + +int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags) +{ + int blk; + int pg; + + __u8 *x; + + + + blk = chunkInNAND/PAGES_PER_BLOCK; + pg = chunkInNAND%PAGES_PER_BLOCK; + + + if(data) + { + memcpy(data,ned.block[blk]->page[pg]->data,PAGE_DATA_SIZE); + } + + + if(tags) + { + x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; + + yaffs_UnpackTags2(tags,(yaffs_PackedTags2 *)x); + } + + return YAFFS_OK; +} + + +int nandemul2k_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) +{ + int blk; + int pg; + int i; + + + + blk = chunkInNAND/PAGES_PER_BLOCK; + pg = chunkInNAND%PAGES_PER_BLOCK; + + + for(i = 0; i < PAGE_TOTAL_SIZE; i++) + { + if(ned.block[blk]->page[pg]->data[i] != 0xFF) + { + return YAFFS_FAIL; + } + } + + return YAFFS_OK; + +} + +int nandemul2k_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +{ + + + if(blockNumber < 0 || blockNumber >= ned.nBlocks) + { + T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber)); + } + else if(ned.block[blockNumber]->damaged) + { + T(YAFFS_TRACE_ALWAYS,("Attempt to erase damaged block %d\n",blockNumber)); + } + else + { + nandemul_ReallyEraseBlock(blockNumber); + } + + return YAFFS_OK; +} + +int nandemul2k_InitialiseNAND(yaffs_Device *dev) +{ + CheckInit(); + return YAFFS_OK; +} + +int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +{ + + __u8 *x; + + x = &ned.block[blockNo]->page[0]->data[PAGE_DATA_SIZE]; + + memset(x,0,sizeof(yaffs_PackedTags2)); + + + return YAFFS_OK; + +} + +int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber) +{ + yaffs_ExtendedTags tags; + int chunkNo; + + *sequenceNumber = 0; + + chunkNo = blockNo * dev->nChunksPerBlock; + + nandemul2k_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags); + if(tags.blockBad) + { + *state = YAFFS_BLOCK_STATE_DEAD; + } + else if(!tags.chunkUsed) + { + *state = YAFFS_BLOCK_STATE_EMPTY; + } + else if(tags.chunkUsed) + { + *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + *sequenceNumber = tags.sequenceNumber; + } + return YAFFS_OK; +} + +int nandemul2k_GetBytesPerChunk(void) { return PAGE_DATA_SIZE;} + +int nandemul2k_GetChunksPerBlock(void) { return PAGES_PER_BLOCK; } +int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();} + + +#endif //YAFFS_RAM_ENABLED + diff --git a/yportenv.h b/yportenv.h index a1a2074..aa211e7 100644 --- a/yportenv.h +++ b/yportenv.h @@ -15,7 +15,7 @@ * * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. * - * $Id: yportenv.h,v 1.4 2004-11-22 03:22:25 charles Exp $ + * $Id: yportenv.h,v 1.5 2004-12-17 04:39:04 charles Exp $ * */ @@ -147,6 +147,8 @@ extern unsigned yaffs_traceMask; #define YAFFS_TRACE_BUFFERS 0x00000400 #define YAFFS_TRACE_NANDACCESS 0x00000800 #define YAFFS_TRACE_GC_DETAIL 0x00001000 +#define YAFFS_TRACE_SCAN_DEBUG 0x00002000 +#define YAFFS_TRACE_MTD 0x00004000 #define YAFFS_TRACE_ALWAYS 0x40000000 #define YAFFS_TRACE_BUG 0x80000000