X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=direct%2Fyaffs_fileem2k.c;h=db90496eea148277f617c0e3aba7d0cc270b598a;hp=786094b349a307c5ab28ba41feb05f068086e1b4;hb=49942b13d7cfbdba72c18de0f37d16d81b4372a8;hpb=40b1e54e4e59aaeb6bafabcda5df47bddc5ecfee

diff --git a/direct/yaffs_fileem2k.c b/direct/yaffs_fileem2k.c
index 786094b..db90496 100644
--- a/direct/yaffs_fileem2k.c
+++ b/direct/yaffs_fileem2k.c
@@ -1,26 +1,27 @@
 /*
- * YAFFS: Yet another FFS. A NAND-flash specific file system. 
- * yaffs_ramdisk.c: yaffs ram disk component
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  *
- * Copyright (C) 2002 Aleph One Ltd.
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
  *
  * 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 provides a YAFFS nand emulation on a file for emulating 2kB pages.
-// THis is only intended as test code to test persistence etc.
+/*
+ * This provides a YAFFS nand emulation on a file for emulating 2kB pages.
+ * This is only intended as test code to test persistence etc.
+ */
 
-const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.3 2005-07-03 05:48:11 charles Exp $";
+const char *yaffs_flashif2_c_version = "$Id: yaffs_fileem2k.c,v 1.15 2008-07-21 01:03:19 charles Exp $";
 
 
 #include "yportenv.h"
 
-#include "yaffs_flashif.h"
+#include "yaffs_flashif2.h"
 #include "yaffs_guts.h"
 #include "devextras.h"
 
@@ -32,8 +33,11 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.3 2005-07-03 05
 #include "yaffs_fileem2k.h"
 #include "yaffs_packedtags2.h"
 
+//#define SIMULATE_FAILURES
 
 
+#define REPORT_ERROR 0
+
 typedef struct 
 {
 	__u8 data[PAGE_SIZE]; // Data + spare
@@ -47,25 +51,65 @@ typedef struct
 
 
 
+#define MAX_HANDLES 20
+#define BLOCKS_PER_HANDLE 8000
+
 typedef struct
 {
-	int handle;
+	int handle[MAX_HANDLES];
 	int nBlocks;
 } yflash_Device;
 
 static yflash_Device filedisk;
 
-static int  CheckInit(yaffs_Device *dev)
+int yaffs_testPartialWrite = 0;
+
+
+
+
+static __u8 localBuffer[PAGE_SIZE];
+
+static char *NToName(char *buf,int n)
 {
-	static int initialised = 0;
-	
-	int i;
+	sprintf(buf,"emfile2k-%d",n);
+	return buf;
+}
+
+static char dummyBuffer[BLOCK_SIZE];
 
+static int GetBlockFileHandle(int n)
+{
+	int h;
+	int requiredSize;
 	
+	char name[40];
+	NToName(name,n);
 	int fSize;
-	int written;
+	int i;
 	
-	yflash_Page p;
+	h =  open(name, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+	if(h >= 0){
+		fSize = lseek(h,0,SEEK_END);
+		requiredSize = BLOCKS_PER_HANDLE * BLOCK_SIZE;
+		if(fSize < requiredSize){
+		   for(i = 0; i < BLOCKS_PER_HANDLE; i++)
+		   	if(write(h,dummyBuffer,BLOCK_SIZE) != BLOCK_SIZE)
+				return -1;
+			
+		}
+	}
+	
+	return h;
+
+}
+
+static int  CheckInit(void)
+{
+	static int initialised = 0;
+	int i;
+
+	int blk;
+
 	
 	if(initialised) 
 	{
@@ -74,103 +118,153 @@ static int  CheckInit(yaffs_Device *dev)
 
 	initialised = 1;
 	
+	memset(dummyBuffer,0xff,sizeof(dummyBuffer));
 	
-	filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
-	
-	filedisk.handle = open("yaffsemfile2k", O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
 	
-	if(filedisk.handle < 0)
-	{
-		perror("Failed to open yaffs emulation file");
-		return YAFFS_FAIL;
-	}
+	filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
+
+	for(i = 0; i <  MAX_HANDLES; i++)
+		filedisk.handle[i] = -1;
 	
+	for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
+		filedisk.handle[i] = GetBlockFileHandle(i);
 	
-	fSize = lseek(filedisk.handle,0,SEEK_END);
-	
-	if(fSize < filedisk.nBlocks * BLOCK_SIZE)
-	{
-		printf("Creating yaffs emulation file\n");
-		
-		lseek(filedisk.handle,0,SEEK_SET);
-		
-		memset(&p,0xff,sizeof(yflash_Page));
-		
-		for(i = 0; i <  filedisk.nBlocks * BLOCK_SIZE; i+= PAGE_SIZE)
-		{
-			written = write(filedisk.handle,&p,sizeof(yflash_Page));
-			
-			if(written != sizeof(yflash_Page))
-			{
-				printf("Write failed\n");
-				return YAFFS_FAIL;
-			}
-		}		
-	}
 	
 	return 1;
 }
 
-int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
+
+int yflash2_GetNumberOfBlocks(void)
+{
+	CheckInit();
+	
+	return filedisk.nBlocks;
+}
+
+int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags)
 {
 	int written;
 	int pos;
-
-	CheckInit(dev);
+	int h;
+	int i;
+	int nRead;
+	int error;
 	
+	T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
+
+	CheckInit();
 	
 	
-	if(data)
-	{
-		pos = chunkInNAND * PAGE_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		written = write(filedisk.handle,data,dev->nBytesPerChunk);
+	if(dev->inbandTags){
 		
-		if(written != dev->nBytesPerChunk) return YAFFS_FAIL;
-	}
-	
-	if(tags)
-	{
-		pos = chunkInNAND * PAGE_SIZE + PAGE_DATA_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		if( 0 && dev->isYaffs2)
-		{
-			
-			written = write(filedisk.handle,tags,sizeof(yaffs_ExtendedTags));
-			if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
-		}
-		else
-		{
-			yaffs_PackedTags2 pt;
-			yaffs_PackTags2(&pt,tags);
+		yaffs_PackedTags2TagsPart * pt2tp;
+		pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
+		yaffs_PackTags2TagsPart(pt2tp,tags);
+		
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+				  			
+		lseek(h,pos,SEEK_SET);
+		written = write(h,data,dev->totalBytesPerChunk);
 
-			written = write(filedisk.handle,&pt,sizeof(pt));
-			if(written != sizeof(pt)) return YAFFS_FAIL;
+		
+		if(yaffs_testPartialWrite){
+			close(h);
+			exit(1);
 		}
+		
+		if(written != dev->totalBytesPerChunk) return YAFFS_FAIL;
+
+
 	}
 	
+	else {
+	
+		if(data)
+		{
+			pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+			h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+		
+			lseek(h,pos,SEEK_SET);
+			nRead =  read(h, localBuffer,dev->nDataBytesPerChunk);
+			for(i = error = 0; i < dev->nDataBytesPerChunk && !error; i++){
+				if(REPORT_ERROR && localBuffer[i] != 0xFF){
+					printf("nand simulation: chunk %d data byte %d was %0x2\n",
+						chunkInNAND,i,localBuffer[i]);
+					error = 1;
+				}
+			}
+		
+			for(i = 0; i < dev->nDataBytesPerChunk; i++)
+			localBuffer[i] &= data[i];
+		  
+			if(REPORT_ERROR && memcmp(localBuffer,data,dev->nDataBytesPerChunk))
+				printf("nand simulator: data does not match\n");
+			
+			lseek(h,pos,SEEK_SET);
+			written = write(h,localBuffer,dev->nDataBytesPerChunk);
+		
+			if(yaffs_testPartialWrite){
+				close(h);
+				exit(1);
+			}
+		
+#ifdef SIMULATE_FAILURES
+				if((chunkInNAND >> 6) == 100) 
+				written = 0;
 
-	return YAFFS_OK;	
+				if((chunkInNAND >> 6) == 110) 
+				written = 0;
+#endif
 
-}
 
-int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
-{
-	int written;
+			if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL;
+		}
 	
-	yaffs_PackedTags2 pt;
+		if(tags)
+		{
+			pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
+			h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+		
+			lseek(h,pos,SEEK_SET);
 
-	CheckInit(dev);
-	
-	memset(&pt,0,sizeof(pt));
-	lseek(filedisk.handle,(blockNo * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
-	written = write(filedisk.handle,&pt,sizeof(pt));
+			if( 0 && dev->isYaffs2)
+			{
+			
+				written = write(h,tags,sizeof(yaffs_ExtendedTags));
+				if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
+			}
+			else
+			{
+				yaffs_PackedTags2 pt;
+				yaffs_PackTags2(&pt,tags);
+				__u8 * ptab = (__u8 *)&pt;
+
+				nRead = read(h,localBuffer,sizeof(pt));
+				for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){
+					if(localBuffer[i] != 0xFF){
+						printf("nand simulation: chunk %d oob byte %d was %0x2\n",
+							chunkInNAND,i,localBuffer[i]);
+							error = 1;
+					}
+				}
 		
-	if(written != sizeof(pt)) return YAFFS_FAIL;
-	
-	
-	return YAFFS_OK;
+				for(i = 0; i < sizeof(pt); i++)
+				localBuffer[i] &= ptab[i];
+			 
+				if(REPORT_ERROR && memcmp(localBuffer,&pt,sizeof(pt)))
+					printf("nand sim: tags corruption\n");
+				
+				lseek(h,pos,SEEK_SET);
+			
+				written = write(h,localBuffer,sizeof(pt));
+				if(written != sizeof(pt)) return YAFFS_FAIL;
+			}
+		}
 	
+	}
+	return YAFFS_OK;	
+
 }
 
 int yaffs_CheckAllFF(const __u8 *ptr, int n)
@@ -185,62 +279,164 @@ int yaffs_CheckAllFF(const __u8 *ptr, int n)
 }
 
 
-int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+static int fail300 = 1;
+static int fail320 = 1;
+
+static int failRead10 = 2;
+
+int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
 {
 	int nread;
 	int pos;
-
-	CheckInit(dev);
+	int h;
+	int localData = 0;
+	int retval = YAFFS_OK;
+	int nRead;
 	
+	T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
 	
+	CheckInit();
 	
-	if(data)
-	{
-		pos = chunkInNAND * PAGE_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		nread = read(filedisk.handle,data,dev->nBytesPerChunk);
+	
+	
+	
+	if(dev->inbandTags){
+		/* Got to suck the tags out of the data area */
+		if(!data) {
+			localData=1;
+			data = yaffs_GetTempBuffer(dev,__LINE__);
+		}
+
 		
-		if(nread != dev->nBytesPerChunk) return YAFFS_FAIL;
+		yaffs_PackedTags2TagsPart * pt2tp;
+		pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
+
+		
+		pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+		h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
+		
+		lseek(h,pos,SEEK_SET);
+
+		nRead = read(h, data,dev->totalBytesPerChunk);
+
+		yaffs_UnpackTags2TagsPart(tags,pt2tp);
+		
+		if(nread != dev->totalBytesPerChunk)
+			retval = YAFFS_FAIL;
+			
+		if(localData)
+			yaffs_ReleaseTempBuffer(dev,data,__LINE__);
+
+
+
 	}
 	
-	if(tags)
-	{
-		pos = chunkInNAND * PAGE_SIZE + PAGE_DATA_SIZE;
-		lseek(filedisk.handle,pos,SEEK_SET);
-		if(0 && dev->isYaffs2)
+	else {
+	
+		if(data)
 		{
-			nread= read(filedisk.handle,tags,sizeof(yaffs_ExtendedTags));
-			if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
-			if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
+
+			pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
+			h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];		
+			lseek(h,pos,SEEK_SET);
+			nread = read(h,data,dev->nDataBytesPerChunk);
+		
+		
+			if(nread != dev->nDataBytesPerChunk) 
+				retval = YAFFS_FAIL;
+		}
+	
+		if(tags)
+		{
+			pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
+			h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];		
+			lseek(h,pos,SEEK_SET);
+
+			if(0 && dev->isYaffs2)
 			{
-				yaffs_InitialiseTags(tags);
+				nread= read(h,tags,sizeof(yaffs_ExtendedTags));
+				if(nread != sizeof(yaffs_ExtendedTags))
+					 retval =  YAFFS_FAIL;
+				if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
+				{
+					yaffs_InitialiseTags(tags);
+				}
+				else
+				{
+					tags->chunkUsed = 1;
+				}
 			}
 			else
 			{
-				tags->chunkUsed = 1;
+				yaffs_PackedTags2 pt;
+				nread= read(h,&pt,sizeof(pt));
+				yaffs_UnpackTags2(tags,&pt);
+#ifdef SIMULATE_FAILURES
+				if((chunkInNAND >> 6) == 100) {
+					if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
+						tags->eccResult = YAFFS_ECC_RESULT_FIXED;
+						fail300 = 0;
+					}
+				}
+				
+				if((chunkInNAND >> 6) == 110) {
+					if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
+						tags->eccResult = YAFFS_ECC_RESULT_FIXED;
+						fail320 = 0;
+					}
+				}
+#endif
+				if(failRead10>0 && chunkInNAND == 10){
+					failRead10--;
+					nread = 0;
+				}
+			
+				if(nread != sizeof(pt))
+					retval = YAFFS_FAIL;
 			}
 		}
-		else
-		{
-			yaffs_PackedTags2 pt;
-			nread= read(filedisk.handle,&pt,sizeof(pt));
-			yaffs_UnpackTags2(tags,&pt);
-			if(nread != sizeof(pt)) return YAFFS_FAIL;
-		}
 	}
 	
 
-	return YAFFS_OK;	
+
+	return retval;	
 
 }
 
 
-int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+int yflash2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+	int written;
+	int h;
+	
+	yaffs_PackedTags2 pt;
+
+	CheckInit();
+	
+	memset(&pt,0,sizeof(pt));
+	h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))];
+	lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
+	written = write(h,&pt,sizeof(pt));
+		
+	if(written != sizeof(pt)) return YAFFS_FAIL;
+	
+	
+	return YAFFS_OK;
+	
+}
+
+int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 {
 
 	int i;
+	int h;
 		
-	CheckInit(dev);
+	CheckInit();
+	
+	printf("erase block %d\n",blockNumber);
+	
+	if(blockNumber == 320)
+		fail320 = 1;
 	
 	if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
 	{
@@ -256,22 +452,23 @@ int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 		
 		memset(pg,0xff,syz);
 		
-		pos = lseek(filedisk.handle, blockNumber * dev->nChunksPerBlock * PAGE_SIZE, SEEK_SET);
-		
+
+		h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
+		lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE,SEEK_SET);		
 		for(i = 0; i < dev->nChunksPerBlock; i++)
 		{
-			write(filedisk.handle,pg,PAGE_SIZE);
+			write(h,pg,PAGE_SIZE);
 		}
-		pos = lseek(filedisk.handle, 0,SEEK_CUR);
+		pos = lseek(h, 0,SEEK_CUR);
 		
 		return YAFFS_OK;
 	}
 	
 }
 
-int yflash_InitialiseNAND(yaffs_Device *dev)
+int yflash2_InitialiseNAND(yaffs_Device *dev)
 {
-	CheckInit(dev);
+	CheckInit();
 	
 	return YAFFS_OK;
 }
@@ -279,7 +476,7 @@ int yflash_InitialiseNAND(yaffs_Device *dev)
 
 
 
-int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
+int yflash2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber)
 {
 	yaffs_ExtendedTags tags;
 	int chunkNo;
@@ -288,7 +485,7 @@ int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_Blo
 	
 	chunkNo = blockNo * dev->nChunksPerBlock;
 	
-	yflash_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
+	yflash2_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
 	if(tags.blockBad)
 	{
 		*state = YAFFS_BLOCK_STATE_DEAD;