direct/yaffs_fileem2k.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffs_ramdisk.c: yaffs ram disk component
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  */
  14
  15 // This provides a YAFFS nand emulation on a file for emulating 2kB pages.
  16 // THis is only intended as test code to test persistence etc.
  17
  18 const char *yaffs_flashif_c_version = "$Id: yaffs_fileem2k.c,v 1.8 2006-11-07 23:37:43 charles Exp $";
  19
  20
  21 #include "yportenv.h"
  22
  23 #include "yaffs_flashif.h"
  24 #include "yaffs_guts.h"
  25 #include "devextras.h"
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31
  32 #include "yaffs_fileem2k.h"
  33 #include "yaffs_packedtags2.h"
  34
  35 //#define SIMULATE_FAILURES
  36
  37 typedef struct
  38 {
  39         __u8 data[PAGE_SIZE]; // Data + spare
  40 } yflash_Page;
  41
  42 typedef struct
  43 {
  44         yflash_Page page[PAGES_PER_BLOCK]; // The pages in the block
  45
  46 } yflash_Block;
  47
  48
  49
  50 #define MAX_HANDLES 20
  51 #define BLOCKS_PER_HANDLE 8000
  52
  53 typedef struct
  54 {
  55         int handle[MAX_HANDLES];
  56         int nBlocks;
  57 } yflash_Device;
  58
  59 static yflash_Device filedisk;
  60
  61 int yaffs_testPartialWrite = 0;
  62
  63
  64 static char *NToName(char *buf,int n)
  65 {
  66         sprintf(buf,"emfile%d",n);
  67         return buf;
  68 }
  69
  70 static char dummyBuffer[BLOCK_SIZE];
  71
  72 static int GetBlockFileHandle(int n)
  73 {
  74         int h;
  75         int requiredSize;
  76
  77         char name[40];
  78         NToName(name,n);
  79         int fSize;
  80         int i;
  81
  82         h =  open(name, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
  83         if(h >= 0){
  84                 fSize = lseek(h,0,SEEK_END);
  85                 requiredSize = BLOCKS_PER_HANDLE * BLOCK_SIZE;
  86                 if(fSize < requiredSize){
  87                    for(i = 0; i < BLOCKS_PER_HANDLE; i++)
  88                         if(write(h,dummyBuffer,BLOCK_SIZE) != BLOCK_SIZE)
  89                                 return -1;
  90
  91                 }
  92         }
  93
  94         return h;
  95
  96 }
  97
  98 static int  CheckInit(void)
  99 {
 100         static int initialised = 0;
 101         int h;
 102         int i;
 103
 104
 105         off_t fSize;
 106         off_t requiredSize;
 107         int written;
 108         int blk;
 109
 110         yflash_Page p;
 111
 112         if(initialised)
 113         {
 114                 return YAFFS_OK;
 115         }
 116
 117         initialised = 1;
 118
 119         memset(dummyBuffer,0xff,sizeof(dummyBuffer));
 120
 121
 122         filedisk.nBlocks = SIZE_IN_MB * BLOCKS_PER_MB;
 123
 124         for(i = 0; i <  MAX_HANDLES; i++)
 125                 filedisk.handle[i] = -1;
 126
 127         for(i = 0,blk = 0; blk < filedisk.nBlocks; blk+=BLOCKS_PER_HANDLE,i++)
 128                 filedisk.handle[i] = GetBlockFileHandle(i);
 129
 130
 131         return 1;
 132 }
 133
 134
 135 int yflash_GetNumberOfBlocks(void)
 136 {
 137         CheckInit();
 138
 139         return filedisk.nBlocks;
 140 }
 141
 142 int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags)
 143 {
 144         int written;
 145         int pos;
 146         int h;
 147
 148         T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
 149
 150         CheckInit();
 151
 152
 153
 154         if(data)
 155         {
 156                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
 157                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 158
 159                 lseek(h,pos,SEEK_SET);
 160                 written = write(h,data,dev->nDataBytesPerChunk);
 161
 162                 if(yaffs_testPartialWrite){
 163                         close(h);
 164                         exit(1);
 165                 }
 166
 167                 if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 168         }
 169
 170         if(tags)
 171         {
 172                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
 173                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 174
 175                 lseek(h,pos,SEEK_SET);
 176                 if( 0 && dev->isYaffs2)
 177                 {
 178
 179                         written = write(h,tags,sizeof(yaffs_ExtendedTags));
 180                         if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 181                 }
 182                 else
 183                 {
 184                         yaffs_PackedTags2 pt;
 185                         yaffs_PackTags2(&pt,tags);
 186
 187                         written = write(h,&pt,sizeof(pt));
 188                         if(written != sizeof(pt)) return YAFFS_FAIL;
 189                 }
 190         }
 191
 192
 193         return YAFFS_OK;
 194
 195 }
 196
 197 int yaffs_CheckAllFF(const __u8 *ptr, int n)
 198 {
 199         while(n)
 200         {
 201                 n--;
 202                 if(*ptr!=0xFF) return 0;
 203                 ptr++;
 204         }
 205         return 1;
 206 }
 207
 208
 209 static int fail300 = 1;
 210 static int fail320 = 1;
 211
 212 int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
 213 {
 214         int nread;
 215         int pos;
 216         int h;
 217
 218         T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags));
 219
 220         CheckInit();
 221
 222
 223
 224         if(data)
 225         {
 226
 227                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
 228                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 229                 lseek(h,pos,SEEK_SET);
 230                 nread = read(h,data,dev->nDataBytesPerChunk);
 231
 232                 if(nread != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 233         }
 234
 235         if(tags)
 236         {
 237                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
 238                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 239                 lseek(h,pos,SEEK_SET);
 240
 241                 if(0 && dev->isYaffs2)
 242                 {
 243                         nread= read(h,tags,sizeof(yaffs_ExtendedTags));
 244                         if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 245                         if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
 246                         {
 247                                 yaffs_InitialiseTags(tags);
 248                         }
 249                         else
 250                         {
 251                                 tags->chunkUsed = 1;
 252                         }
 253                 }
 254                 else
 255                 {
 256                         yaffs_PackedTags2 pt;
 257                         nread= read(h,&pt,sizeof(pt));
 258                         yaffs_UnpackTags2(tags,&pt);
 259 #ifdef SIMULATE_FAILURES
 260                         if((chunkInNAND >> 6) == 300) {
 261                             if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
 262                                tags->eccResult = YAFFS_ECC_RESULT_FIXED;
 263                                fail300 = 0;
 264                             }
 265
 266                         }
 267                         if((chunkInNAND >> 6) == 320) {
 268                             if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){
 269                                tags->eccResult = YAFFS_ECC_RESULT_FIXED;
 270                                fail320 = 0;
 271                             }
 272                         }
 273 #endif
 274                         if(nread != sizeof(pt)) return YAFFS_FAIL;
 275                 }
 276         }
 277
 278
 279         return YAFFS_OK;
 280
 281 }
 282
 283
 284 int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 285 {
 286         int written;
 287         int h;
 288
 289         yaffs_PackedTags2 pt;
 290
 291         CheckInit();
 292
 293         memset(&pt,0,sizeof(pt));
 294         h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))];
 295         lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
 296         written = write(h,&pt,sizeof(pt));
 297
 298         if(written != sizeof(pt)) return YAFFS_FAIL;
 299
 300
 301         return YAFFS_OK;
 302
 303 }
 304
 305 int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 306 {
 307
 308         int i;
 309         int h;
 310
 311         CheckInit();
 312
 313         if(blockNumber == 320)
 314                 fail320 = 1;
 315
 316         if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
 317         {
 318                 T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
 319                 return YAFFS_FAIL;
 320         }
 321         else
 322         {
 323
 324                 __u8 pg[PAGE_SIZE];
 325                 int syz = PAGE_SIZE;
 326                 int pos;
 327
 328                 memset(pg,0xff,syz);
 329
 330
 331                 h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
 332                 lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE,SEEK_SET);
 333                 for(i = 0; i < dev->nChunksPerBlock; i++)
 334                 {
 335                         write(h,pg,PAGE_SIZE);
 336                 }
 337                 pos = lseek(h, 0,SEEK_CUR);
 338
 339                 return YAFFS_OK;
 340         }
 341
 342 }
 343
 344 int yflash_InitialiseNAND(yaffs_Device *dev)
 345 {
 346         CheckInit();
 347
 348         return YAFFS_OK;
 349 }
 350
 351
 352
 353
 354 int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
 355 {
 356         yaffs_ExtendedTags tags;
 357         int chunkNo;
 358
 359         *sequenceNumber = 0;
 360
 361         chunkNo = blockNo * dev->nChunksPerBlock;
 362
 363         yflash_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
 364         if(tags.blockBad)
 365         {
 366                 *state = YAFFS_BLOCK_STATE_DEAD;
 367         }
 368         else if(!tags.chunkUsed)
 369         {
 370                 *state = YAFFS_BLOCK_STATE_EMPTY;
 371         }
 372         else if(tags.chunkUsed)
 373         {
 374                 *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
 375                 *sequenceNumber = tags.sequenceNumber;
 376         }
 377         return YAFFS_OK;
 378 }
 379