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.6 2006-10-03 10:13:03 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
  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         CheckInit();
 149
 150
 151
 152         if(data)
 153         {
 154                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
 155                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 156
 157                 lseek(h,pos,SEEK_SET);
 158                 written = write(h,data,dev->nDataBytesPerChunk);
 159
 160                 if(yaffs_testPartialWrite){
 161                         close(h);
 162                         exit(1);
 163                 }
 164
 165                 if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 166         }
 167
 168         if(tags)
 169         {
 170                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ;
 171                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 172
 173                 lseek(h,pos,SEEK_SET);
 174                 if( 0 && dev->isYaffs2)
 175                 {
 176
 177                         written = write(h,tags,sizeof(yaffs_ExtendedTags));
 178                         if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 179                 }
 180                 else
 181                 {
 182                         yaffs_PackedTags2 pt;
 183                         yaffs_PackTags2(&pt,tags);
 184
 185                         written = write(h,&pt,sizeof(pt));
 186                         if(written != sizeof(pt)) return YAFFS_FAIL;
 187                 }
 188         }
 189
 190
 191         return YAFFS_OK;
 192
 193 }
 194
 195 int yaffs_CheckAllFF(const __u8 *ptr, int n)
 196 {
 197         while(n)
 198         {
 199                 n--;
 200                 if(*ptr!=0xFF) return 0;
 201                 ptr++;
 202         }
 203         return 1;
 204 }
 205
 206
 207 int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
 208 {
 209         int nread;
 210         int pos;
 211         int h;
 212
 213         CheckInit();
 214
 215
 216
 217         if(data)
 218         {
 219
 220                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE;
 221                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 222                 lseek(h,pos,SEEK_SET);
 223                 nread = read(h,data,dev->nDataBytesPerChunk);
 224
 225                 if(nread != dev->nDataBytesPerChunk) return YAFFS_FAIL;
 226         }
 227
 228         if(tags)
 229         {
 230                 pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE;
 231                 h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))];
 232                 lseek(h,pos,SEEK_SET);
 233
 234                 if(0 && dev->isYaffs2)
 235                 {
 236                         nread= read(h,tags,sizeof(yaffs_ExtendedTags));
 237                         if(nread != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL;
 238                         if(yaffs_CheckAllFF((__u8 *)tags,sizeof(yaffs_ExtendedTags)))
 239                         {
 240                                 yaffs_InitialiseTags(tags);
 241                         }
 242                         else
 243                         {
 244                                 tags->chunkUsed = 1;
 245                         }
 246                 }
 247                 else
 248                 {
 249                         yaffs_PackedTags2 pt;
 250                         nread= read(h,&pt,sizeof(pt));
 251                         yaffs_UnpackTags2(tags,&pt);
 252                         if(nread != sizeof(pt)) return YAFFS_FAIL;
 253                 }
 254         }
 255
 256
 257         return YAFFS_OK;
 258
 259 }
 260
 261
 262 int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
 263 {
 264         int written;
 265         int h;
 266
 267         yaffs_PackedTags2 pt;
 268
 269         CheckInit();
 270
 271         memset(&pt,0,sizeof(pt));
 272         h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))];
 273         lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET);
 274         written = write(h,&pt,sizeof(pt));
 275
 276         if(written != sizeof(pt)) return YAFFS_FAIL;
 277
 278
 279         return YAFFS_OK;
 280
 281 }
 282
 283 int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 284 {
 285
 286         int i;
 287         int h;
 288
 289         CheckInit();
 290
 291         if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
 292         {
 293                 T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
 294                 return YAFFS_FAIL;
 295         }
 296         else
 297         {
 298
 299                 __u8 pg[PAGE_SIZE];
 300                 int syz = PAGE_SIZE;
 301                 int pos;
 302
 303                 memset(pg,0xff,syz);
 304
 305
 306                 h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))];
 307                 lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->nChunksPerBlock) * PAGE_SIZE,SEEK_SET);
 308                 for(i = 0; i < dev->nChunksPerBlock; i++)
 309                 {
 310                         write(h,pg,PAGE_SIZE);
 311                 }
 312                 pos = lseek(h, 0,SEEK_CUR);
 313
 314                 return YAFFS_OK;
 315         }
 316
 317 }
 318
 319 int yflash_InitialiseNAND(yaffs_Device *dev)
 320 {
 321         CheckInit();
 322
 323         return YAFFS_OK;
 324 }
 325
 326
 327
 328
 329 int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber)
 330 {
 331         yaffs_ExtendedTags tags;
 332         int chunkNo;
 333
 334         *sequenceNumber = 0;
 335
 336         chunkNo = blockNo * dev->nChunksPerBlock;
 337
 338         yflash_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags);
 339         if(tags.blockBad)
 340         {
 341                 *state = YAFFS_BLOCK_STATE_DEAD;
 342         }
 343         else if(!tags.chunkUsed)
 344         {
 345                 *state = YAFFS_BLOCK_STATE_EMPTY;
 346         }
 347         else if(tags.chunkUsed)
 348         {
 349                 *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
 350                 *sequenceNumber = tags.sequenceNumber;
 351         }
 352         return YAFFS_OK;
 353 }
 354