mtdemul/nandemul2k.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   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  *  This version hacked for emulating 2kpage NAND for YAFFS2 testing.
  15  */
  16
  17 #include <linux/config.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/version.h>
  21 #include <linux/slab.h>
  22 #include <linux/init.h>
  23 #include <linux/list.h>
  24 #include <linux/fs.h>
  25 #include <linux/proc_fs.h>
  26 #include <linux/pagemap.h>
  27 #include <linux/mtd/mtd.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/string.h>
  30 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  31 #include <linux/locks.h>
  32 #endif
  33
  34 #include <asm/uaccess.h>
  35 #include <linux/mtd/mtd.h>
  36 #include <linux/mtd/partitions.h>
  37 #include <linux/mtd/nand.h>
  38 #include "../yaffs_nandemul2k.h"
  39
  40 #define ALLOCATE(x) kmalloc(x,GFP_KERNEL)
  41 #define FREE(x)     kfree(x)
  42
  43
  44
  45
  46
  47 #define EM_SIZE_IN_MEG 4
  48 #define PAGE_DATA_SIZE  (2048)
  49 #define PAGE_SPARE_SIZE (64)
  50 #define PAGES_PER_BLOCK (64)
  51 #define NAND_SHIFT      (11)   // Shifter for 2k
  52
  53
  54 #define EM_SIZE_IN_BYTES (EM_SIZE_IN_MEG * (1<<20))
  55
  56 #define PAGE_TOTAL_SIZE (PAGE_DATA_SIZE+PAGE_SPARE_SIZE)
  57
  58 #define BLOCK_TOTAL_SIZE (PAGES_PER_BLOCK * PAGE_TOTAL_SIZE)
  59
  60 #define BLOCKS_PER_MEG ((1<<20)/(PAGES_PER_BLOCK * PAGE_DATA_SIZE))
  61
  62
  63 static struct mtd_info nandemul2k_mtd;
  64
  65 typedef struct
  66 {
  67         __u8 data[PAGE_TOTAL_SIZE]; // Data + spare
  68         int empty;      // is this empty?
  69 } nandemul_Page;
  70
  71
  72 typedef struct
  73 {
  74         nandemul_Page *page[PAGES_PER_BLOCK];
  75         int damaged;
  76 } nandemul_Block;
  77
  78
  79
  80 typedef struct
  81 {
  82         nandemul_Block**block;
  83         int nBlocks;
  84 } nandemul_Device;
  85
  86 static nandemul_Device ned;
  87
  88 static int sizeInMB = EM_SIZE_IN_MEG;
  89
  90
  91 static void nandemul_yield(int n)
  92 {
  93 #ifdef __KERNEL__
  94         if(n > 0) schedule_timeout(n);
  95 #endif
  96
  97 }
  98
  99
 100 static void nandemul2k_Read(void *buffer, int page, int start, int nBytes)
 101 {
 102         int pg = page%PAGES_PER_BLOCK;
 103         int blk = page/PAGES_PER_BLOCK;
 104         if(buffer && nBytes > 0)
 105         {
 106                 memcpy(buffer,&ned.block[blk]->page[pg]->data[start],nBytes);
 107         }
 108
 109 }
 110
 111 static void nandemul2k_Program(const void *buffer, int page, int start, int nBytes)
 112 {
 113         int pg = page%PAGES_PER_BLOCK;
 114         int blk = page/PAGES_PER_BLOCK;
 115         __u8 *p;
 116         __u8 *b = (__u8 *)buffer;
 117
 118         p = &ned.block[blk]->page[pg]->data[start];
 119
 120         while(buffer && nBytes>0)
 121         {
 122                 *p = *p & *b;
 123                 p++;
 124                 b++;
 125                 nBytes--;
 126         }
 127 }
 128
 129 static void nandemul2k_DoErase(int blockNumber)
 130 {
 131         int i;
 132
 133         nandemul_Block *blk;
 134
 135         if(blockNumber < 0 || blockNumber >= ned.nBlocks)
 136         {
 137                 return;
 138         }
 139
 140         blk = ned.block[blockNumber];
 141
 142         for(i = 0; i < PAGES_PER_BLOCK; i++)
 143         {
 144                 memset(blk->page[i],0xff,sizeof(nandemul_Page));
 145                 blk->page[i]->empty = 1;
 146         }
 147         nandemul_yield(2);
 148 }
 149
 150
 151 static int nandemul2k_CalcNBlocks(void)
 152 {
 153         return EM_SIZE_IN_MEG * BLOCKS_PER_MEG;
 154 }
 155
 156
 157
 158 static int  CheckInit(void)
 159 {
 160         static int initialised = 0;
 161
 162         int i,j;
 163
 164         int fail = 0;
 165         int nBlocks;
 166
 167         int nAllocated = 0;
 168
 169         if(initialised)
 170         {
 171                 return 0;
 172         }
 173
 174
 175         ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks();
 176
 177
 178         ned.block = ALLOCATE(sizeof(nandemul_Block*) * nBlocks );
 179
 180         if(!ned.block) return ENOMEM;
 181
 182
 183
 184
 185
 186         for(i=fail=0; i <nBlocks; i++)
 187         {
 188
 189                 nandemul_Block *blk;
 190
 191                 if(!(blk = ned.block[i] = ALLOCATE(sizeof(nandemul_Block))))
 192                 {
 193                  fail = 1;
 194                 }
 195                 else
 196                 {
 197                         for(j = 0; j < PAGES_PER_BLOCK; j++)
 198                         {
 199                                 if((blk->page[j] = ALLOCATE(sizeof(nandemul_Page))) == 0)
 200                                 {
 201                                         fail = 1;
 202                                 }
 203                         }
 204                         nandemul2k_DoErase(i);
 205                         ned.block[i]->damaged = 0;
 206                         nAllocated++;
 207                 }
 208         }
 209
 210         if(fail)
 211         {
 212                 //Todo thump pages
 213
 214                 for(i = 0; i < nAllocated; i++)
 215                 {
 216                         FREE(ned.block[i]);
 217                 }
 218                 FREE(ned.block);
 219
 220                 return ENOMEM;
 221         }
 222
 223         ned.nBlocks = nBlocks;
 224
 225         initialised = 1;
 226
 227         return 1;
 228 }
 229
 230
 231
 232 static void nandemul2k_CleanUp(void)
 233 {
 234         int i,j;
 235
 236         for(i = 0; i < ned.nBlocks; i++)
 237         {
 238                 for(j = 0; j < PAGES_PER_BLOCK; j++)
 239                 {
 240                    FREE(ned.block[i]->page[j]);
 241                 }
 242                 FREE(ned.block[i]);
 243
 244         }
 245         FREE(ned.block);
 246         ned.block = 0;
 247 }
 248
 249 int nandemul2k_GetBytesPerChunk(void) { return PAGE_DATA_SIZE;}
 250
 251 int nandemul2k_GetChunksPerBlock(void) { return PAGES_PER_BLOCK; }
 252 int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();}
 253
 254
 255
 256 int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId)
 257 {
 258         *vendorId = 'Y';
 259         *deviceId = '2';
 260
 261         return 1;
 262 }
 263
 264
 265 int nandemul2k_ReadStatus(__u8 *status)
 266 {
 267                 *status = 0;
 268                 return 1;
 269 }
 270
 271
 272 #ifdef CONFIG_MTD_NAND_ECC
 273 #include <linux/mtd/nand_ecc.h>
 274 #endif
 275
 276 /*
 277  * NAND low-level MTD interface functions
 278  */
 279 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
 280                         size_t *retlen, u_char *buf);
 281 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
 282                                 size_t *retlen, u_char *buf, u_char *oob_buf, struct nand_oobinfo *dummy);
 283 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
 284                                 size_t *retlen, u_char *buf);
 285 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
 286                         size_t *retlen, const u_char *buf);
 287 static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
 288                                 size_t *retlen, const u_char *buf,
 289                                 const u_char *oob_buf, struct nand_oobinfo *dummy);
 290 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
 291                                 size_t *retlen, const u_char *buf);
 292 static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
 293                                 unsigned long count, loff_t to, size_t *retlen);
 294 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr);
 295 static void nand_sync (struct mtd_info *mtd);
 296
 297
 298
 299 /*
 300  * NAND read
 301  */
 302 static int nand_read (struct mtd_info *mtd, loff_t from, size_t len,
 303                         size_t *retlen, u_char *buf)
 304 {
 305         return nand_read_ecc (mtd, from, len, retlen, buf, NULL,NULL);
 306 }
 307
 308
 309 /*
 310  * NAND read with ECC
 311  */
 312 static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
 313                                 size_t *retlen, u_char *buf, u_char *oob_buf,struct nand_oobinfo *oobsel)
 314 {
 315         int     start, page;
 316         int n = len;
 317         int nToCopy;
 318
 319
 320
 321         /* Do not allow reads past end of device */
 322         if ((from + len) > mtd->size) {
 323                 *retlen = 0;
 324                 return -EINVAL;
 325         }
 326
 327
 328         /* Initialize return value */
 329         *retlen = 0;
 330
 331         while(n > 0)
 332         {
 333
 334                 /* First we calculate the starting page */
 335                 page = from >> NAND_SHIFT;
 336
 337                 /* Get raw starting column */
 338
 339                 start = from & (mtd->oobblock-1);
 340
 341                 // OK now check for the curveball where the start and end are in
 342                 // the same page
 343                 if((start + n) < mtd->oobblock)
 344                 {
 345                         nToCopy = n;
 346                 }
 347                 else
 348                 {
 349                         nToCopy =  mtd->oobblock - start;
 350                 }
 351
 352                 nandemul2k_Read(buf, page, start, nToCopy);
 353                 nandemul2k_Read(oob_buf,page,PAGE_DATA_SIZE,PAGE_SPARE_SIZE);
 354
 355                 n -= nToCopy;
 356                 from += nToCopy;
 357                 buf += nToCopy;
 358                 if(oob_buf) oob_buf += PAGE_SPARE_SIZE;
 359                 *retlen += nToCopy;
 360
 361         }
 362
 363
 364         return 0;
 365 }
 366
 367 /*
 368  * NAND read out-of-band
 369  */
 370 static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
 371                                 size_t *retlen, u_char *buf)
 372 {
 373         int col, page;
 374
 375         T(0,("nand_read_oob: from = 0x%08x, buf = 0x%08x, len = %i\n", (unsigned int) from, (unsigned int) buf,
 376                 (int) len));
 377
 378         /* Shift to get page */
 379         page = ((int) from) >> NAND_SHIFT;
 380
 381         /* Mask to get column */
 382         col = from & 0x0f;
 383
 384         /* Initialize return length value */
 385         *retlen = 0;
 386
 387         /* Do not allow reads past end of device */
 388         if ((from + len) > mtd->size) {
 389                 T(0,
 390                         ("nand_read_oob: Attempt read beyond end of device\n"));
 391                 *retlen = 0;
 392                 return -EINVAL;
 393         }
 394
 395         nandemul2k_Read(buf,page,PAGE_DATA_SIZE + col,len);
 396
 397         /* Return happy */
 398         *retlen = len;
 399         return 0;
 400 }
 401
 402 /*
 403  * NAND write
 404  */
 405 static int nand_write (struct mtd_info *mtd, loff_t to, size_t len,
 406                         size_t *retlen, const u_char *buf)
 407 {
 408         return nand_write_ecc (mtd, to, len, retlen, buf, NULL,NULL);
 409 }
 410
 411 /*
 412  * NAND write with ECC
 413  */
 414 static int nand_write_ecc (struct mtd_info *mtd, loff_t to, size_t len,
 415                                 size_t *retlen, const u_char *buf,
 416                                 const u_char *oob_buf, struct nand_oobinfo *dummy)
 417 {
 418
 419         int     start, page;
 420         int n = len;
 421         int nToCopy;
 422
 423
 424
 425         /* Do not allow reads past end of device */
 426         if ((to + len) > mtd->size) {
 427                 *retlen = 0;
 428                 return -EINVAL;
 429         }
 430
 431
 432         /* Initialize return value */
 433         *retlen = 0;
 434
 435         while(n > 0)
 436         {
 437
 438                 /* First we calculate the starting page */
 439                 page = to >> NAND_SHIFT;
 440
 441                 /* Get raw starting column */
 442
 443                 start = to & (mtd->oobblock - 1);
 444
 445                 // OK now check for the curveball where the start and end are in
 446                 // the same page
 447                 if((start + n) < mtd->oobblock)
 448                 {
 449                         nToCopy = n;
 450                 }
 451                 else
 452                 {
 453                         nToCopy =  mtd->oobblock - start;
 454                 }
 455
 456                 nandemul2k_Program(buf, page, start, nToCopy);
 457                 nandemul2k_Program(oob_buf, page, PAGE_DATA_SIZE, PAGE_SPARE_SIZE);
 458
 459                 n -= nToCopy;
 460                 to += nToCopy;
 461                 buf += nToCopy;
 462                 if(oob_buf) oob_buf += PAGE_SPARE_SIZE;
 463                 *retlen += nToCopy;
 464
 465         }
 466
 467
 468         return 0;
 469 }
 470
 471 /*
 472  * NAND write out-of-band
 473  */
 474 static int nand_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
 475                                 size_t *retlen, const u_char *buf)
 476 {
 477         int col, page;
 478
 479
 480         T(0,(
 481                 "nand_read_oob: to = 0x%08x, len = %i\n", (unsigned int) to,
 482                 (int) len));
 483
 484         /* Shift to get page */
 485         page = ((int) to) >> NAND_SHIFT;
 486
 487         /* Mask to get column */
 488         col = to & 0x0f;
 489
 490         /* Initialize return length value */
 491         *retlen = 0;
 492
 493         /* Do not allow reads past end of device */
 494         if ((to + len) > mtd->size) {
 495                 T(0,(
 496                    "nand_read_oob: Attempt read beyond end of device\n"));
 497                 *retlen = 0;
 498                 return -EINVAL;
 499         }
 500
 501         nandemul2k_Program(buf,page,512 + col,len);
 502
 503         /* Return happy */
 504         *retlen = len;
 505         return 0;
 506
 507 }
 508
 509 /*
 510  * NAND write with iovec
 511  */
 512 static int nand_writev (struct mtd_info *mtd, const struct iovec *vecs,
 513                                 unsigned long count, loff_t to, size_t *retlen)
 514 {
 515         return -EINVAL;
 516 }
 517
 518 /*
 519  * NAND erase a block
 520  */
 521 static int nand_erase (struct mtd_info *mtd, struct erase_info *instr)
 522 {
 523         int i, nBlocks,block;
 524
 525         T(0,(
 526                 "nand_erase: start = 0x%08x, len = %i\n",
 527                 (unsigned int) instr->addr, (unsigned int) instr->len));
 528
 529         /* Start address must align on block boundary */
 530         if (instr->addr & (mtd->erasesize - 1)) {
 531                 T(0,(
 532                         "nand_erase: Unaligned address\n"));
 533                 return -EINVAL;
 534         }
 535
 536         /* Length must align on block boundary */
 537         if (instr->len & (mtd->erasesize - 1)) {
 538                 T(0,(
 539                         "nand_erase: Length not block aligned\n"));
 540                 return -EINVAL;
 541         }
 542
 543         /* Do not allow erase past end of device */
 544         if ((instr->len + instr->addr) > mtd->size) {
 545                 T(0,(
 546                         "nand_erase: Erase past end of device\n"));
 547                 return -EINVAL;
 548         }
 549
 550         nBlocks = instr->len >> (NAND_SHIFT + 5);
 551         block = instr->addr >> (NAND_SHIFT + 5);
 552
 553         for(i = 0; i < nBlocks; i++)
 554         {
 555                 nandemul2k_DoErase(block);
 556                 block++;
 557         }
 558
 559
 560
 561         return 0;
 562
 563
 564 }
 565
 566
 567 int nand_block_isbad(struct mtd_info *mtd,int blockNo)
 568 {
 569         return 0;
 570 }
 571
 572 int nand_block_markbad(struct mtd_info *mtd, int blockNo)
 573 {
 574         return 0;
 575 }
 576
 577
 578 /*
 579  * NAND sync
 580  */
 581 static void nand_sync (struct mtd_info *mtd)
 582 {
 583         T(0,("nand_sync: called\n"));
 584
 585 }
 586
 587 /*
 588  * Scan for the NAND device
 589  */
 590 int nand_scan (struct mtd_info *mtd,int nchips)
 591 {
 592         mtd->oobblock = PAGE_DATA_SIZE;
 593         mtd->oobsize =  PAGE_SPARE_SIZE;
 594         mtd->erasesize = PAGE_DATA_SIZE * PAGES_PER_BLOCK;
 595         mtd->size = sizeInMB * 1024*1024;
 596
 597
 598
 599         /* Fill in remaining MTD driver data */
 600         mtd->type = MTD_NANDFLASH;
 601         mtd->flags = MTD_CAP_NANDFLASH;
 602         mtd->owner = THIS_MODULE;
 603         mtd->ecctype = MTD_ECC_NONE;
 604         mtd->erase = nand_erase;
 605         mtd->point = NULL;
 606         mtd->unpoint = NULL;
 607         mtd->read = nand_read;
 608         mtd->write = nand_write;
 609         mtd->read_ecc = nand_read_ecc;
 610         mtd->write_ecc = nand_write_ecc;
 611         mtd->read_oob = nand_read_oob;
 612         mtd->write_oob = nand_write_oob;
 613         mtd->block_isbad = nand_block_isbad;
 614         mtd->block_markbad = nand_block_markbad;
 615         mtd->readv = NULL;
 616         mtd->writev = nand_writev;
 617         mtd->sync = nand_sync;
 618         mtd->lock = NULL;
 619         mtd->unlock = NULL;
 620         mtd->suspend = NULL;
 621         mtd->resume = NULL;
 622
 623         /* Return happy */
 624         return 0;
 625 }
 626
 627 #if 0
 628 #ifdef MODULE
 629 MODULE_PARM(sizeInMB, "i");
 630
 631 __setup("sizeInMB=",sizeInMB);
 632 #endif
 633 #endif
 634
 635 /*
 636  * Define partitions for flash devices
 637  */
 638
 639 static struct mtd_partition nandemul2k_partition[] =
 640 {
 641         { name: "NANDemul partition 1",
 642           offset:  0,
 643           size: 0 },
 644 };
 645
 646 static int nPartitions = sizeof(nandemul2k_partition)/sizeof(nandemul2k_partition[0]);
 647
 648 /*
 649  * Main initialization routine
 650  */
 651 int __init nandemul2k_init (void)
 652 {
 653
 654         // Do the nand init
 655
 656         CheckInit();
 657
 658         nand_scan(&nandemul2k_mtd,1);
 659
 660         // Build the partition table
 661
 662         nandemul2k_partition[0].size = sizeInMB * 1024 * 1024;
 663
 664         // Register the partition
 665         add_mtd_partitions(&nandemul2k_mtd,nandemul2k_partition,nPartitions);
 666
 667         return 0;
 668
 669 }
 670
 671 module_init(nandemul2k_init);
 672
 673 /*
 674  * Clean up routine
 675  */
 676 #ifdef MODULE
 677 static void __exit nandemul2k_cleanup (void)
 678 {
 679
 680         nandemul2k_CleanUp();
 681
 682         /* Unregister partitions */
 683         del_mtd_partitions(&nandemul2k_mtd);
 684
 685         /* Unregister the device */
 686         del_mtd_device (&nandemul2k_mtd);
 687
 688 }
 689 module_exit(nandemul2k_cleanup);
 690 #endif
 691
 692 MODULE_LICENSE("GPL");
 693 MODULE_AUTHOR("Charles Manning <manningc@aleph1.co.uk>");
 694 MODULE_DESCRIPTION("2k Page/128k Block NAND emulated in RAM");
 695
 696
 697
 698