mtdemul/nandemul2k.c

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