yaffs_ramem.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffs_ramem.c  NAND emulation on top of a chunk of RAM
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *   for Toby Churchill Ltd and Brightstar Engineering
   7  *
   8  * Created by Charles Manning <charles@aleph1.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15  //yaffs_ramem.c
  16  // Since this creates the RAM block at start up it is pretty useless for testing the scanner.
  17
  18 #ifndef __KERNEL__
  19 #define CONFIG_YAFFS_RAM_ENABLED
  20 #endif
  21
  22 #ifdef CONFIG_YAFFS_RAM_ENABLED
  23
  24 #include "yportenv.h"
  25
  26 #include "yaffs_nandemul.h"
  27 #include "yaffs_guts.h"
  28 #include "yaffsinterface.h"
  29 #include "devextras.h"
  30
  31
  32 #define EM_SIZE_IN_MEG 2
  33
  34 #define BLOCK_SIZE (32 * 528)
  35 #define BLOCKS_PER_MEG ((1024*1024)/(32 * 512))
  36 #define FILE_SIZE_IN_BLOCKS (FILE_SIZE_IN_MEG * BLOCKS_PER_MEG)
  37 #define FILE_SIZE_IN_BYTES (FILE_SIZE_IN_BLOCKS * BLOCK_SIZE)
  38
  39 #define T(x) YPRINTF(x)
  40
  41 #define DEFAULT_SIZE_IN_MB 2
  42
  43 typedef struct
  44 {
  45         __u8 data[528]; // Data + spare
  46         int count[3];   // The programming count for each area of
  47                         // the page (0..255,256..511,512..527
  48         int empty;      // is this empty?
  49 } nandemul_Page;
  50
  51 typedef struct
  52 {
  53         nandemul_Page page[32]; // The pages in the block
  54         __u8 damaged;           // Is the block damaged?
  55
  56 } nandemul_Block;
  57
  58
  59
  60 typedef struct
  61 {
  62         nandemul_Block **block;
  63         int nBlocks;
  64 } nandemul_Device;
  65
  66 static nandemul_Device ned;
  67
  68 int sizeInMB = DEFAULT_SIZE_IN_MB;
  69
  70
  71 static void nandemul_yield(int n)
  72 {
  73 #ifdef __KERNEL__
  74         if(n > 0) schedule_timeout(n);
  75 #endif
  76
  77 }
  78
  79
  80 static void nandemul_ReallyEraseBlock(int blockNumber)
  81 {
  82         int i;
  83
  84         nandemul_Block *theBlock = ned.block[blockNumber];
  85
  86         for(i = 0; i < 32; i++)
  87         {
  88                 memset(theBlock->page[i].data,0xff,528);
  89                 theBlock->page[i].count[0] = 0;
  90                 theBlock->page[i].count[1] = 0;
  91                 theBlock->page[i].count[2] = 0;
  92                 theBlock->page[i].empty = 1;
  93                 nandemul_yield(2);
  94         }
  95
  96 }
  97
  98
  99 int nandemul_CalcNBlocks(void)
 100 {
 101         switch(sizeInMB)
 102         {
 103                 case 8:
 104                 case 16:
 105                 case 32:
 106                 case 64:
 107                 case 128:
 108                 case 256:
 109                 case 512:
 110                         break;
 111                 default:
 112                         sizeInMB = DEFAULT_SIZE_IN_MB;
 113         }
 114         return sizeInMB * 64;
 115 }
 116
 117
 118
 119 static int  CheckInit(void)
 120 {
 121         static int initialised = 0;
 122
 123         int i;
 124         int fail = 0;
 125         int nBlocks;
 126         int nAllocated = 0;
 127
 128         if(initialised)
 129         {
 130                 return YAFFS_OK;
 131         }
 132
 133
 134         nBlocks = nandemul_CalcNBlocks();
 135
 136         ned.block = YMALLOC(sizeof(nandemul_Block *) * nBlocks);
 137
 138         if(!ned.block) return 0;
 139
 140         for(i=0; i <nBlocks; i++)
 141         {
 142                 ned.block[i] = NULL;
 143         }
 144
 145         for(i=0; i <nBlocks && !fail; i++)
 146         {
 147                 if((ned.block[i] = YMALLOC(sizeof(nandemul_Block))) == 0)
 148                 {
 149                         fail = 1;
 150                 }
 151                 else
 152                 {
 153                         nandemul_ReallyEraseBlock(i);
 154                         ned.block[i]->damaged = 0;
 155                         nAllocated++;
 156                 }
 157         }
 158
 159         if(fail)
 160         {
 161                 for(i = 0; i < nAllocated; i++)
 162                 {
 163                         YFREE(ned.block[i]);
 164                 }
 165                 YFREE(ned.block);
 166
 167                 T(("Allocation failed, could only allocate %dMB of %dMB requested.\n",
 168                    nAllocated/64,sizeInMB));
 169                 return 0;
 170         }
 171
 172         ned.nBlocks = nBlocks;
 173
 174         initialised = 1;
 175
 176         return 1;
 177 }
 178
 179 int nandemul_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_Spare *spare)
 180 {
 181         int blk;
 182         int pg;
 183         int i;
 184
 185         __u8 *x;
 186
 187         __u8 *spareAsBytes = (__u8 *)spare;
 188
 189
 190         CheckInit();
 191
 192         blk = chunkInNAND/32;
 193         pg = chunkInNAND%32;
 194
 195
 196         if(data)
 197         {
 198                 x = ned.block[blk]->page[pg].data;
 199
 200                 for(i = 0; i < 512; i++)
 201                 {
 202                         x[i] &=data[i];
 203                 }
 204
 205                 ned.block[blk]->page[pg].count[0]++;
 206                 ned.block[blk]->page[pg].count[1]++;
 207                 ned.block[blk]->page[pg].empty = 0;
 208         }
 209
 210
 211         if(spare)
 212         {
 213                 x = &ned.block[blk]->page[pg].data[512];
 214
 215                 for(i = 0; i < 16; i++)
 216                 {
 217                         x[i] &=spareAsBytes[i];
 218                 }
 219                 ned.block[blk]->page[pg].count[2]++;
 220         }
 221
 222         if(spare || data)
 223         {
 224                 nandemul_yield(1);
 225         }
 226
 227         return YAFFS_OK;
 228 }
 229
 230
 231 int nandemul_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare)
 232 {
 233         int blk;
 234         int pg;
 235
 236
 237         CheckInit();
 238
 239         blk = chunkInNAND/32;
 240         pg = chunkInNAND%32;
 241
 242
 243         if(data)
 244         {
 245                 memcpy(data,ned.block[blk]->page[pg].data,512);
 246         }
 247
 248
 249         if(spare)
 250         {
 251                 memcpy(spare,&ned.block[blk]->page[pg].data[512],16);
 252         }
 253
 254         return YAFFS_OK;
 255 }
 256
 257
 258 int nandemul_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
 259 {
 260         int blk;
 261         int pg;
 262         int i;
 263
 264
 265         CheckInit();
 266
 267         blk = chunkInNAND/32;
 268         pg = chunkInNAND%32;
 269
 270
 271         for(i = 0; i < 528; i++)
 272         {
 273                 if(ned.block[blk]->page[pg].data[i] != 0xFF)
 274                 {
 275                         return YAFFS_FAIL;
 276                 }
 277         }
 278
 279         return YAFFS_OK;
 280
 281 }
 282
 283 int nandemul_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
 284 {
 285
 286         CheckInit();
 287
 288         if(blockNumber < 0 || blockNumber >= ned.nBlocks)
 289         {
 290                 T(("Attempt to erase non-existant block %d\n",blockNumber));
 291         }
 292         else if(ned.block[blockNumber]->damaged)
 293         {
 294                 T(("Attempt to erase damaged block %d\n",blockNumber));
 295         }
 296         else
 297         {
 298                 nandemul_ReallyEraseBlock(blockNumber);
 299         }
 300
 301         return YAFFS_OK;
 302 }
 303
 304 int nandemul_InitialiseNAND(yaffs_Device *dev)
 305 {
 306         return YAFFS_OK;
 307 }
 308
 309 #endif //YAFFS_RAM_ENABLED
 310