direct/test-framework/yaffs_m18_drv.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2018 Aleph One Ltd.
   5  *
   6  * Created by Charles Manning <charles@aleph1.co.uk>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 /*
  14  * This is an interface module for handling NOR in yaffs1 mode.
  15  */
  16
  17 /* First set up for M18 with 1k chunks and 16-byte spares.
  18  *
  19  * NB We're using the oddball M18 modes of operation here
  20  * The chip is 64MB based at 0x0000, but YAFFS only going to use the top half
  21  * ie. YAFFS will be from 32MB to 64MB.
  22  *
  23  * The M18 has two ways of writing data. Every Programming Region (1kbytes)
  24  * can be programmed in two modes:
  25  * * Object Mode 1024 bytes of write once data.
  26  * * Control Mode: 512bytes of bit-writeable data.
  27  *    This is arranged as 32 * (16 bytes of bit-writable followed by 16 bytes of "dont touch")
  28  *
  29  * The block size is 256kB, making 128 blocks in the 32MB YAFFS area.
  30  * Each block comprises:
  31  *   Offset   0k: 248 x 1k data pages
  32  *   Offset 248k: 248 x 32-byte spare areas implemented as 16 bytes of spare followed by 16 bytes untouched)
  33  *   Offset 248k + (248 * 32): Format marker
  34  *
  35  */
  36
  37 #include "yaffs_m18_drv.h"
  38
  39 #include "yportenv.h"
  40 #include "yaffs_trace.h"
  41
  42 #include "yaffs_flashif.h"
  43 #include "yaffs_guts.h"
  44
  45 #define SPARE_BYTES_PER_CHUNK   16
  46 #define M18_SKIP                16
  47 #define PROG_REGION_SIZE        1024
  48 #define BLOCK_SIZE_IN_BYTES     (256*1024)
  49 #define CHUNKS_PER_BLOCK        248
  50 #define SPARE_AREA_OFFSET       (CHUNKS_PER_BLOCK * PROG_REGION_SIZE)
  51
  52 #define FORMAT_OFFSET           (SPARE_AREA_OFFSET + CHUNKS_PER_BLOCK * \
  53                                 (SPARE_BYTES_PER_CHUNK + M18_SKIP))
  54
  55 #define FORMAT_VALUE            0x1234
  56
  57 #define DATA_BYTES_PER_CHUNK    1024
  58 #define BLOCKS_IN_DEVICE        (8*1024/256)
  59
  60
  61 #define YNOR_PREMARKER          (0xF6)
  62 #define YNOR_POSTMARKER         (0xF0)
  63
  64
  65 #if 1
  66
  67 /* Compile this for a simulation */
  68 #include "ynorsim.h"
  69
  70 static struct nor_sim *nor_sim;
  71
  72 #define m18_drv_FlashInit() do {nor_sim = ynorsim_initialise("emfile-m18", BLOCKS_IN_DEVICE, BLOCK_SIZE_IN_BYTES); } while(0)
  73 #define m18_drv_FlashDeinit() ynorsim_shutdown(nor_sim)
  74 #define m18_drv_FlashWrite32(addr,buf,nwords) ynorsim_wr32(nor_sim,addr,buf,nwords)
  75 #define m18_drv_FlashRead32(addr,buf,nwords) ynorsim_rd32(nor_sim,addr,buf,nwords)
  76 #define m18_drv_FlashEraseBlock(addr) ynorsim_erase(nor_sim,addr)
  77 #define DEVICE_BASE     ynorsim_get_base(nor_sim)
  78
  79 #else
  80
  81 /* Compile this to hook up to read hardware */
  82 #include "../blob/yflashrw.h"
  83 #define m18_drv_FlashInit()  do{} while(0)
  84 #define m18_drv_FlashDeinit() do {} while(0)
  85 #define m18_drv_FlashWrite32(addr,buf,nwords) Y_FlashWrite(addr,buf,nwords)
  86 #define m18_drv_FlashRead32(addr,buf,nwords)  Y_FlashRead(addr,buf,nwords)
  87 #define m18_drv_FlashEraseBlock(addr)         Y_FlashErase(addr,BLOCK_SIZE_IN_BYTES)
  88 #define DEVICE_BASE     (32 * 1024 * 1024)
  89 #endif
  90
  91
  92 static u32 *Block2Addr(struct yaffs_dev *dev, int blockNumber)
  93 {
  94         u8 *addr;
  95         dev=dev;
  96
  97         addr = (u8*) DEVICE_BASE;
  98         addr += blockNumber * BLOCK_SIZE_IN_BYTES;
  99
 100         return (u32 *) addr;
 101 }
 102
 103 static u32 *Block2FormatAddr(struct yaffs_dev *dev,int blockNumber)
 104 {
 105         u8 *addr;
 106
 107         addr = (u8*) Block2Addr(dev,blockNumber);
 108         addr += FORMAT_OFFSET;
 109
 110         return (u32 *)addr;
 111 }
 112
 113 static u32 *Chunk2DataAddr(struct yaffs_dev *dev,int chunk_id)
 114 {
 115         unsigned block;
 116         unsigned chunkInBlock;
 117         u8 *addr;
 118
 119         block = chunk_id/dev->param.chunks_per_block;
 120         chunkInBlock = chunk_id % dev->param.chunks_per_block;
 121
 122         addr = (u8*) Block2Addr(dev,block);
 123         addr += chunkInBlock * DATA_BYTES_PER_CHUNK;
 124
 125         return (u32 *)addr;
 126 }
 127
 128 static u32 *Chunk2SpareAddr(struct yaffs_dev *dev,int chunk_id)
 129 {
 130         unsigned block;
 131         unsigned chunkInBlock;
 132         u8 *addr;
 133
 134         block = chunk_id/dev->param.chunks_per_block;
 135         chunkInBlock = chunk_id % dev->param.chunks_per_block;
 136
 137         addr = (u8*) Block2Addr(dev,block);
 138         addr += SPARE_AREA_OFFSET;
 139         addr += chunkInBlock * (SPARE_BYTES_PER_CHUNK + M18_SKIP);
 140         return (u32 *)addr;
 141 }
 142
 143
 144 static void m18_drv_AndBytes(u8*target, const u8   *src, int nbytes)
 145 {
 146         while(nbytes > 0){
 147                 *target &= *src;
 148                 target++;
 149                 src++;
 150                 nbytes--;
 151         }
 152 }
 153
 154 static int m18_drv_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,
 155                                     const u8 *data, int data_len,
 156                                     const u8 *oob, int oob_len)
 157 {
 158         u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
 159         u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
 160
 161         struct yaffs_spare *spare = (struct yaffs_spare *)oob;
 162         struct yaffs_spare tmpSpare;
 163
 164         (void) oob_len;
 165
 166         /* We should only be getting called for one of 3 reasons:
 167          * Writing a chunk: data and spare will not be NULL
 168          * Writing a deletion marker: data will be NULL, spare not NULL
 169          * Writing a bad block marker: data will be NULL, spare not NULL
 170          */
 171
 172         if(sizeof(struct yaffs_spare) != 16)
 173                 BUG();
 174
 175         if(data && oob)
 176         {
 177                 if(spare->page_status != 0xff)
 178                         BUG();
 179                 /* Write a pre-marker */
 180                 memset(&tmpSpare,0xff,sizeof(tmpSpare));
 181                 tmpSpare.page_status = YNOR_PREMARKER;
 182                 m18_drv_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4);
 183
 184                 /* Write the data */
 185                 m18_drv_FlashWrite32(dataAddr,(u32 *)data, data_len/ 4);
 186
 187
 188                 memcpy(&tmpSpare,spare,sizeof(struct yaffs_spare));
 189
 190                 /* Write the real tags, but override the premarker*/
 191                 tmpSpare.page_status = YNOR_PREMARKER;
 192                 m18_drv_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4);
 193
 194                 /* Write a post-marker */
 195                 tmpSpare.page_status = YNOR_POSTMARKER;
 196                 m18_drv_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(tmpSpare)/4);
 197
 198         } else if(spare){
 199                 /* This has to be a read-modify-write operation to handle NOR-ness */
 200
 201                 m18_drv_FlashRead32(spareAddr,(u32 *)&tmpSpare,16/ 4);
 202
 203                 m18_drv_AndBytes((u8 *)&tmpSpare,(u8 *)spare,sizeof(struct yaffs_spare));
 204
 205                 m18_drv_FlashWrite32(spareAddr,(u32 *)&tmpSpare,16/ 4);
 206         }
 207         else {
 208                 BUG();
 209         }
 210
 211
 212         return YAFFS_OK;
 213
 214 }
 215
 216 static int m18_drv_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk,
 217                                         u8 *data, int data_len,
 218                                         u8 *oob, int oob_len,
 219                                         enum yaffs_ecc_result *ecc_result)
 220 {
 221         struct yaffs_spare *spare = (struct yaffs_spare *)oob;
 222
 223         u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
 224         u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
 225
 226         (void) data_len;
 227
 228         if(data)
 229         {
 230                 m18_drv_FlashRead32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4);
 231         }
 232
 233         if(oob)
 234         {
 235                 m18_drv_FlashRead32(spareAddr,(u32 *)spare, oob_len/ 4);
 236
 237                 /* If the page status is YNOR_POSTMARKER then it was written properly
 238                  * so change that to 0xFF so that the rest of yaffs is happy.
 239                  */
 240                 if(spare->page_status == YNOR_POSTMARKER)
 241                         spare->page_status = 0xFF;
 242                 else if(spare->page_status != 0xff &&
 243                         (spare->page_status | YNOR_PREMARKER) != 0xff)
 244                         spare->page_status = YNOR_PREMARKER;
 245         }
 246
 247         if(ecc_result)
 248                 *ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
 249
 250         return YAFFS_OK;
 251
 252 }
 253
 254
 255 static int m18_drv_FormatBlock(struct yaffs_dev *dev, int blockNumber)
 256 {
 257         u32 *blockAddr = Block2Addr(dev,blockNumber);
 258         u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
 259         u32 formatValue = FORMAT_VALUE;
 260
 261         m18_drv_FlashEraseBlock(blockAddr);
 262         m18_drv_FlashWrite32(formatAddr,&formatValue,1);
 263
 264         return YAFFS_OK;
 265 }
 266
 267 static int m18_drv_UnformatBlock(struct yaffs_dev *dev, int blockNumber)
 268 {
 269         u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
 270         u32 formatValue = 0;
 271
 272         m18_drv_FlashWrite32(formatAddr,&formatValue,1);
 273
 274         return YAFFS_OK;
 275 }
 276
 277 static int m18_drv_IsBlockFormatted(struct yaffs_dev *dev, int blockNumber)
 278 {
 279         u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
 280         u32 formatValue;
 281
 282
 283         m18_drv_FlashRead32(formatAddr,&formatValue,1);
 284
 285         return (formatValue == FORMAT_VALUE);
 286 }
 287
 288 static int m18_drv_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 289 {
 290
 291         if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE)
 292         {
 293                 yaffs_trace(YAFFS_TRACE_ALWAYS,
 294                         "Attempt to erase non-existant block %d\n",
 295                         blockNumber);
 296                 return YAFFS_FAIL;
 297         }
 298         else
 299         {
 300                 m18_drv_UnformatBlock(dev,blockNumber);
 301                 m18_drv_FormatBlock(dev,blockNumber);
 302                 return YAFFS_OK;
 303         }
 304
 305 }
 306
 307 static int m18_drv_InitialiseNAND(struct yaffs_dev *dev)
 308 {
 309         u32 i;
 310
 311         m18_drv_FlashInit();
 312         /* Go through the blocks formatting them if they are not formatted */
 313         for(i = dev->param.start_block; i <= dev->param.end_block; i++){
 314                 if(!m18_drv_IsBlockFormatted(dev,i)){
 315                         m18_drv_FormatBlock(dev,i);
 316                 }
 317         }
 318         return YAFFS_OK;
 319 }
 320
 321 static int m18_drv_Deinitialise_flash_fn(struct yaffs_dev *dev)
 322 {
 323         dev=dev;
 324
 325         m18_drv_FlashDeinit();
 326
 327         return YAFFS_OK;
 328 }
 329
 330
 331 struct yaffs_dev *yaffs_m18_install_drv(const char *name)
 332 {
 333
 334         struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
 335         char *name_copy = strdup(name);
 336         struct yaffs_param *param;
 337         struct yaffs_driver *drv;
 338
 339
 340         if(!dev || !name_copy) {
 341                 free(name_copy);
 342                 free(dev);
 343                 return NULL;
 344         }
 345
 346         param = &dev->param;
 347         drv = &dev->drv;
 348
 349         memset(dev, 0, sizeof(*dev));
 350
 351         param->name = name_copy;
 352
 353         param->total_bytes_per_chunk = 1024;
 354         param->chunks_per_block =248;
 355         param->n_reserved_blocks = 2;
 356         param->start_block = 0; // Can use block 0
 357         param->end_block = 31; // Last block
 358         param->use_nand_ecc = 0; // use YAFFS's ECC
 359
 360         drv->drv_write_chunk_fn = m18_drv_WriteChunkToNAND;
 361         drv->drv_read_chunk_fn = m18_drv_ReadChunkFromNAND;
 362         drv->drv_erase_fn = m18_drv_EraseBlockInNAND;
 363         drv->drv_initialise_fn = m18_drv_InitialiseNAND;
 364         drv->drv_deinitialise_fn = m18_drv_Deinitialise_flash_fn;
 365
 366         param->n_caches = 10;
 367         param->disable_soft_del = 1;
 368
 369         dev->driver_context = (void *) 1;       // Used to identify the device in fstat.
 370
 371         yaffs_add_device(dev);
 372
 373         return NULL;
 374 }