drivers/mtd/nftlcore.c

   1 /* Linux driver for NAND Flash Translation Layer      */
   2 /* (c) 1999 Machine Vision Holdings, Inc.             */
   3 /* Author: David Woodhouse <dwmw2@infradead.org>      */
   4 /* $Id: nftlcore.c,v 1.98 2005/11/07 11:14:21 gleixner Exp $ */
   5
   6 /*
   7   The contents of this file are distributed under the GNU General
   8   Public License version 2. The author places no additional
   9   restrictions of any kind on it.
  10  */
  11
  12 #define PRERELEASE
  13
  14 #include <linux/config.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <asm/errno.h>
  18 #include <asm/io.h>
  19 #include <asm/uaccess.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/pci.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/sched.h>
  25 #include <linux/init.h>
  26 #include <linux/hdreg.h>
  27
  28 #include <linux/kmod.h>
  29 #include <linux/mtd/mtd.h>
  30 #include <linux/mtd/nand.h>
  31 #include <linux/mtd/nftl.h>
  32 #include <linux/mtd/blktrans.h>
  33
  34 /* maximum number of loops while examining next block, to have a
  35    chance to detect consistency problems (they should never happen
  36    because of the checks done in the mounting */
  37
  38 #define MAX_LOOPS 10000
  39
  40
  41 static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
  42 {
  43         struct NFTLrecord *nftl;
  44         unsigned long temp;
  45
  46         if (mtd->type != MTD_NANDFLASH)
  47                 return;
  48         /* OK, this is moderately ugly.  But probably safe.  Alternatives? */
  49         if (memcmp(mtd->name, "DiskOnChip", 10))
  50                 return;
  51
  52         if (!mtd->block_isbad) {
  53                 printk(KERN_ERR
  54 "NFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
  55 "Please use the new diskonchip driver under the NAND subsystem.\n");
  56                 return;
  57         }
  58
  59         DEBUG(MTD_DEBUG_LEVEL1, "NFTL: add_mtd for %s\n", mtd->name);
  60
  61         nftl = kmalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
  62
  63         if (!nftl) {
  64                 printk(KERN_WARNING "NFTL: out of memory for data structures\n");
  65                 return;
  66         }
  67         memset(nftl, 0, sizeof(*nftl));
  68
  69         nftl->mbd.mtd = mtd;
  70         nftl->mbd.devnum = -1;
  71         nftl->mbd.blksize = 512;
  72         nftl->mbd.tr = tr;
  73
  74         if (NFTL_mount(nftl) < 0) {
  75                 printk(KERN_WARNING "NFTL: could not mount device\n");
  76                 kfree(nftl);
  77                 return;
  78         }
  79
  80         /* OK, it's a new one. Set up all the data structures. */
  81
  82         /* Calculate geometry */
  83         nftl->cylinders = 1024;
  84         nftl->heads = 16;
  85
  86         temp = nftl->cylinders * nftl->heads;
  87         nftl->sectors = nftl->mbd.size / temp;
  88         if (nftl->mbd.size % temp) {
  89                 nftl->sectors++;
  90                 temp = nftl->cylinders * nftl->sectors;
  91                 nftl->heads = nftl->mbd.size / temp;
  92
  93                 if (nftl->mbd.size % temp) {
  94                         nftl->heads++;
  95                         temp = nftl->heads * nftl->sectors;
  96                         nftl->cylinders = nftl->mbd.size / temp;
  97                 }
  98         }
  99
 100         if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
 101                 /*
 102                   Oh no we don't have
 103                    mbd.size == heads * cylinders * sectors
 104                 */
 105                 printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
 106                        "match size of 0x%lx.\n", nftl->mbd.size);
 107                 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
 108                         "(== 0x%lx sects)\n",
 109                         nftl->cylinders, nftl->heads , nftl->sectors,
 110                         (long)nftl->cylinders * (long)nftl->heads *
 111                         (long)nftl->sectors );
 112         }
 113
 114         if (add_mtd_blktrans_dev(&nftl->mbd)) {
 115                 kfree(nftl->ReplUnitTable);
 116                 kfree(nftl->EUNtable);
 117                 kfree(nftl);
 118                 return;
 119         }
 120 #ifdef PSYCHO_DEBUG
 121         printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
 122 #endif
 123 }
 124
 125 static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
 126 {
 127         struct NFTLrecord *nftl = (void *)dev;
 128
 129         DEBUG(MTD_DEBUG_LEVEL1, "NFTL: remove_dev (i=%d)\n", dev->devnum);
 130
 131         del_mtd_blktrans_dev(dev);
 132         kfree(nftl->ReplUnitTable);
 133         kfree(nftl->EUNtable);
 134         kfree(nftl);
 135 }
 136
 137 /*
 138  * Read oob data from flash
 139  */
 140 int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
 141                   size_t *retlen, uint8_t *buf)
 142 {
 143         struct mtd_oob_ops ops;
 144         int res;
 145
 146         ops.mode = MTD_OOB_PLACE;
 147         ops.ooboffs = offs & (mtd->writesize - 1);
 148         ops.ooblen = len;
 149         ops.oobbuf = buf;
 150         ops.datbuf = NULL;
 151         ops.len = len;
 152
 153         res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 154         *retlen = ops.retlen;
 155         return res;
 156 }
 157
 158 /*
 159  * Write oob data to flash
 160  */
 161 int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
 162                    size_t *retlen, uint8_t *buf)
 163 {
 164         struct mtd_oob_ops ops;
 165         int res;
 166
 167         ops.mode = MTD_OOB_PLACE;
 168         ops.ooboffs = offs & (mtd->writesize - 1);
 169         ops.ooblen = len;
 170         ops.oobbuf = buf;
 171         ops.datbuf = NULL;
 172         ops.len = len;
 173
 174         res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 175         *retlen = ops.retlen;
 176         return res;
 177 }
 178
 179 /*
 180  * Write data and oob to flash
 181  */
 182 static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
 183                       size_t *retlen, uint8_t *buf, uint8_t *oob)
 184 {
 185         struct mtd_oob_ops ops;
 186         int res;
 187
 188         ops.mode = MTD_OOB_PLACE;
 189         ops.ooboffs = offs;
 190         ops.ooblen = mtd->oobsize;
 191         ops.oobbuf = oob;
 192         ops.datbuf = buf;
 193         ops.len = len;
 194
 195         res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 196         *retlen = ops.retlen;
 197         return res;
 198 }
 199
 200 #ifdef CONFIG_NFTL_RW
 201
 202 /* Actual NFTL access routines */
 203 /* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
 204  *      when the give Virtual Unit Chain
 205  */
 206 static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
 207 {
 208         /* For a given Virtual Unit Chain: find or create a free block and
 209            add it to the chain */
 210         /* We're passed the number of the last EUN in the chain, to save us from
 211            having to look it up again */
 212         u16 pot = nftl->LastFreeEUN;
 213         int silly = nftl->nb_blocks;
 214
 215         /* Normally, we force a fold to happen before we run out of free blocks completely */
 216         if (!desperate && nftl->numfreeEUNs < 2) {
 217                 DEBUG(MTD_DEBUG_LEVEL1, "NFTL_findfreeblock: there are too few free EUNs\n");
 218                 return 0xffff;
 219         }
 220
 221         /* Scan for a free block */
 222         do {
 223                 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
 224                         nftl->LastFreeEUN = pot;
 225                         nftl->numfreeEUNs--;
 226                         return pot;
 227                 }
 228
 229                 /* This will probably point to the MediaHdr unit itself,
 230                    right at the beginning of the partition. But that unit
 231                    (and the backup unit too) should have the UCI set
 232                    up so that it's not selected for overwriting */
 233                 if (++pot > nftl->lastEUN)
 234                         pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
 235
 236                 if (!silly--) {
 237                         printk("Argh! No free blocks found! LastFreeEUN = %d, "
 238                                "FirstEUN = %d\n", nftl->LastFreeEUN,
 239                                le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
 240                         return 0xffff;
 241                 }
 242         } while (pot != nftl->LastFreeEUN);
 243
 244         return 0xffff;
 245 }
 246
 247 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
 248 {
 249         struct mtd_info *mtd = nftl->mbd.mtd;
 250         u16 BlockMap[MAX_SECTORS_PER_UNIT];
 251         unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
 252         unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
 253         unsigned int thisEUN;
 254         int block;
 255         int silly;
 256         unsigned int targetEUN;
 257         struct nftl_oob oob;
 258         int inplace = 1;
 259         size_t retlen;
 260
 261         memset(BlockMap, 0xff, sizeof(BlockMap));
 262         memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
 263
 264         thisEUN = nftl->EUNtable[thisVUC];
 265
 266         if (thisEUN == BLOCK_NIL) {
 267                 printk(KERN_WARNING "Trying to fold non-existent "
 268                        "Virtual Unit Chain %d!\n", thisVUC);
 269                 return BLOCK_NIL;
 270         }
 271
 272         /* Scan to find the Erase Unit which holds the actual data for each
 273            512-byte block within the Chain.
 274         */
 275         silly = MAX_LOOPS;
 276         targetEUN = BLOCK_NIL;
 277         while (thisEUN <= nftl->lastEUN ) {
 278                 unsigned int status, foldmark;
 279
 280                 targetEUN = thisEUN;
 281                 for (block = 0; block < nftl->EraseSize / 512; block ++) {
 282                         nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
 283                                       (block * 512), 16 , &retlen,
 284                                       (char *)&oob);
 285                         if (block == 2) {
 286                                 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
 287                                 if (foldmark == FOLD_MARK_IN_PROGRESS) {
 288                                         DEBUG(MTD_DEBUG_LEVEL1,
 289                                               "Write Inhibited on EUN %d\n", thisEUN);
 290                                         inplace = 0;
 291                                 } else {
 292                                         /* There's no other reason not to do inplace,
 293                                            except ones that come later. So we don't need
 294                                            to preserve inplace */
 295                                         inplace = 1;
 296                                 }
 297                         }
 298                         status = oob.b.Status | oob.b.Status1;
 299                         BlockLastState[block] = status;
 300
 301                         switch(status) {
 302                         case SECTOR_FREE:
 303                                 BlockFreeFound[block] = 1;
 304                                 break;
 305
 306                         case SECTOR_USED:
 307                                 if (!BlockFreeFound[block])
 308                                         BlockMap[block] = thisEUN;
 309                                 else
 310                                         printk(KERN_WARNING
 311                                                "SECTOR_USED found after SECTOR_FREE "
 312                                                "in Virtual Unit Chain %d for block %d\n",
 313                                                thisVUC, block);
 314                                 break;
 315                         case SECTOR_DELETED:
 316                                 if (!BlockFreeFound[block])
 317                                         BlockMap[block] = BLOCK_NIL;
 318                                 else
 319                                         printk(KERN_WARNING
 320                                                "SECTOR_DELETED found after SECTOR_FREE "
 321                                                "in Virtual Unit Chain %d for block %d\n",
 322                                                thisVUC, block);
 323                                 break;
 324
 325                         case SECTOR_IGNORE:
 326                                 break;
 327                         default:
 328                                 printk("Unknown status for block %d in EUN %d: %x\n",
 329                                        block, thisEUN, status);
 330                         }
 331                 }
 332
 333                 if (!silly--) {
 334                         printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
 335                                thisVUC);
 336                         return BLOCK_NIL;
 337                 }
 338
 339                 thisEUN = nftl->ReplUnitTable[thisEUN];
 340         }
 341
 342         if (inplace) {
 343                 /* We're being asked to be a fold-in-place. Check
 344                    that all blocks which actually have data associated
 345                    with them (i.e. BlockMap[block] != BLOCK_NIL) are
 346                    either already present or SECTOR_FREE in the target
 347                    block. If not, we're going to have to fold out-of-place
 348                    anyway.
 349                 */
 350                 for (block = 0; block < nftl->EraseSize / 512 ; block++) {
 351                         if (BlockLastState[block] != SECTOR_FREE &&
 352                             BlockMap[block] != BLOCK_NIL &&
 353                             BlockMap[block] != targetEUN) {
 354                                 DEBUG(MTD_DEBUG_LEVEL1, "Setting inplace to 0. VUC %d, "
 355                                       "block %d was %x lastEUN, "
 356                                       "and is in EUN %d (%s) %d\n",
 357                                       thisVUC, block, BlockLastState[block],
 358                                       BlockMap[block],
 359                                       BlockMap[block]== targetEUN ? "==" : "!=",
 360                                       targetEUN);
 361                                 inplace = 0;
 362                                 break;
 363                         }
 364                 }
 365
 366                 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
 367                     pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
 368                     BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
 369                     SECTOR_FREE) {
 370                         DEBUG(MTD_DEBUG_LEVEL1, "Pending write not free in EUN %d. "
 371                               "Folding out of place.\n", targetEUN);
 372                         inplace = 0;
 373                 }
 374         }
 375
 376         if (!inplace) {
 377                 DEBUG(MTD_DEBUG_LEVEL1, "Cannot fold Virtual Unit Chain %d in place. "
 378                       "Trying out-of-place\n", thisVUC);
 379                 /* We need to find a targetEUN to fold into. */
 380                 targetEUN = NFTL_findfreeblock(nftl, 1);
 381                 if (targetEUN == BLOCK_NIL) {
 382                         /* Ouch. Now we're screwed. We need to do a
 383                            fold-in-place of another chain to make room
 384                            for this one. We need a better way of selecting
 385                            which chain to fold, because makefreeblock will
 386                            only ask us to fold the same one again.
 387                         */
 388                         printk(KERN_WARNING
 389                                "NFTL_findfreeblock(desperate) returns 0xffff.\n");
 390                         return BLOCK_NIL;
 391                 }
 392         } else {
 393                 /* We put a fold mark in the chain we are folding only if we
 394                fold in place to help the mount check code. If we do not fold in
 395                place, it is possible to find the valid chain by selecting the
 396                longer one */
 397                 oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
 398                 oob.u.c.unused = 0xffffffff;
 399                 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
 400                                8, &retlen, (char *)&oob.u);
 401         }
 402
 403         /* OK. We now know the location of every block in the Virtual Unit Chain,
 404            and the Erase Unit into which we are supposed to be copying.
 405            Go for it.
 406         */
 407         DEBUG(MTD_DEBUG_LEVEL1,"Folding chain %d into unit %d\n", thisVUC, targetEUN);
 408         for (block = 0; block < nftl->EraseSize / 512 ; block++) {
 409                 unsigned char movebuf[512];
 410                 int ret;
 411
 412                 /* If it's in the target EUN already, or if it's pending write, do nothing */
 413                 if (BlockMap[block] == targetEUN ||
 414                     (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
 415                         continue;
 416                 }
 417
 418                 /* copy only in non free block (free blocks can only
 419                    happen in case of media errors or deleted blocks) */
 420                 if (BlockMap[block] == BLOCK_NIL)
 421                         continue;
 422
 423                 ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block]) + (block * 512),
 424                                 512, &retlen, movebuf);
 425                 if (ret < 0 && ret != -EUCLEAN) {
 426                         ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block])
 427                                         + (block * 512), 512, &retlen,
 428                                         movebuf);
 429                         if (ret != -EIO)
 430                                 printk("Error went away on retry.\n");
 431                 }
 432                 memset(&oob, 0xff, sizeof(struct nftl_oob));
 433                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
 434
 435                 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
 436                            (block * 512), 512, &retlen, movebuf, (char *)&oob);
 437         }
 438
 439         /* add the header so that it is now a valid chain */
 440         oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
 441         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
 442
 443         nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
 444                        8, &retlen, (char *)&oob.u);
 445
 446         /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
 447
 448         /* At this point, we have two different chains for this Virtual Unit, and no way to tell
 449            them apart. If we crash now, we get confused. However, both contain the same data, so we
 450            shouldn't actually lose data in this case. It's just that when we load up on a medium which
 451            has duplicate chains, we need to free one of the chains because it's not necessary any more.
 452         */
 453         thisEUN = nftl->EUNtable[thisVUC];
 454         DEBUG(MTD_DEBUG_LEVEL1,"Want to erase\n");
 455
 456         /* For each block in the old chain (except the targetEUN of course),
 457            free it and make it available for future use */
 458         while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
 459                 unsigned int EUNtmp;
 460
 461                 EUNtmp = nftl->ReplUnitTable[thisEUN];
 462
 463                 if (NFTL_formatblock(nftl, thisEUN) < 0) {
 464                         /* could not erase : mark block as reserved
 465                          */
 466                         nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
 467                 } else {
 468                         /* correctly erased : mark it as free */
 469                         nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
 470                         nftl->numfreeEUNs++;
 471                 }
 472                 thisEUN = EUNtmp;
 473         }
 474
 475         /* Make this the new start of chain for thisVUC */
 476         nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
 477         nftl->EUNtable[thisVUC] = targetEUN;
 478
 479         return targetEUN;
 480 }
 481
 482 static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
 483 {
 484         /* This is the part that needs some cleverness applied.
 485            For now, I'm doing the minimum applicable to actually
 486            get the thing to work.
 487            Wear-levelling and other clever stuff needs to be implemented
 488            and we also need to do some assessment of the results when
 489            the system loses power half-way through the routine.
 490         */
 491         u16 LongestChain = 0;
 492         u16 ChainLength = 0, thislen;
 493         u16 chain, EUN;
 494
 495         for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
 496                 EUN = nftl->EUNtable[chain];
 497                 thislen = 0;
 498
 499                 while (EUN <= nftl->lastEUN) {
 500                         thislen++;
 501                         //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
 502                         EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
 503                         if (thislen > 0xff00) {
 504                                 printk("Endless loop in Virtual Chain %d: Unit %x\n",
 505                                        chain, EUN);
 506                         }
 507                         if (thislen > 0xff10) {
 508                                 /* Actually, don't return failure. Just ignore this chain and
 509                                    get on with it. */
 510                                 thislen = 0;
 511                                 break;
 512                         }
 513                 }
 514
 515                 if (thislen > ChainLength) {
 516                         //printk("New longest chain is %d with length %d\n", chain, thislen);
 517                         ChainLength = thislen;
 518                         LongestChain = chain;
 519                 }
 520         }
 521
 522         if (ChainLength < 2) {
 523                 printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
 524                        "Failing request\n");
 525                 return 0xffff;
 526         }
 527
 528         return NFTL_foldchain (nftl, LongestChain, pendingblock);
 529 }
 530
 531 /* NFTL_findwriteunit: Return the unit number into which we can write
 532                        for this block. Make it available if it isn't already
 533 */
 534 static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
 535 {
 536         u16 lastEUN;
 537         u16 thisVUC = block / (nftl->EraseSize / 512);
 538         struct mtd_info *mtd = nftl->mbd.mtd;
 539         unsigned int writeEUN;
 540         unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
 541         size_t retlen;
 542         int silly, silly2 = 3;
 543         struct nftl_oob oob;
 544
 545         do {
 546                 /* Scan the media to find a unit in the VUC which has
 547                    a free space for the block in question.
 548                 */
 549
 550                 /* This condition catches the 0x[7f]fff cases, as well as
 551                    being a sanity check for past-end-of-media access
 552                 */
 553                 lastEUN = BLOCK_NIL;
 554                 writeEUN = nftl->EUNtable[thisVUC];
 555                 silly = MAX_LOOPS;
 556                 while (writeEUN <= nftl->lastEUN) {
 557                         struct nftl_bci bci;
 558                         size_t retlen;
 559                         unsigned int status;
 560
 561                         lastEUN = writeEUN;
 562
 563                         nftl_read_oob(mtd,
 564                                       (writeEUN * nftl->EraseSize) + blockofs,
 565                                       8, &retlen, (char *)&bci);
 566
 567                         DEBUG(MTD_DEBUG_LEVEL2, "Status of block %d in EUN %d is %x\n",
 568                               block , writeEUN, le16_to_cpu(bci.Status));
 569
 570                         status = bci.Status | bci.Status1;
 571                         switch(status) {
 572                         case SECTOR_FREE:
 573                                 return writeEUN;
 574
 575                         case SECTOR_DELETED:
 576                         case SECTOR_USED:
 577                         case SECTOR_IGNORE:
 578                                 break;
 579                         default:
 580                                 // Invalid block. Don't use it any more. Must implement.
 581                                 break;
 582                         }
 583
 584                         if (!silly--) {
 585                                 printk(KERN_WARNING
 586                                        "Infinite loop in Virtual Unit Chain 0x%x\n",
 587                                        thisVUC);
 588                                 return 0xffff;
 589                         }
 590
 591                         /* Skip to next block in chain */
 592                         writeEUN = nftl->ReplUnitTable[writeEUN];
 593                 }
 594
 595                 /* OK. We didn't find one in the existing chain, or there
 596                    is no existing chain. */
 597
 598                 /* Try to find an already-free block */
 599                 writeEUN = NFTL_findfreeblock(nftl, 0);
 600
 601                 if (writeEUN == BLOCK_NIL) {
 602                         /* That didn't work - there were no free blocks just
 603                            waiting to be picked up. We're going to have to fold
 604                            a chain to make room.
 605                         */
 606
 607                         /* First remember the start of this chain */
 608                         //u16 startEUN = nftl->EUNtable[thisVUC];
 609
 610                         //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
 611                         writeEUN = NFTL_makefreeblock(nftl, 0xffff);
 612
 613                         if (writeEUN == BLOCK_NIL) {
 614                                 /* OK, we accept that the above comment is
 615                                    lying - there may have been free blocks
 616                                    last time we called NFTL_findfreeblock(),
 617                                    but they are reserved for when we're
 618                                    desperate. Well, now we're desperate.
 619                                 */
 620                                 DEBUG(MTD_DEBUG_LEVEL1, "Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
 621                                 writeEUN = NFTL_findfreeblock(nftl, 1);
 622                         }
 623                         if (writeEUN == BLOCK_NIL) {
 624                                 /* Ouch. This should never happen - we should
 625                                    always be able to make some room somehow.
 626                                    If we get here, we've allocated more storage
 627                                    space than actual media, or our makefreeblock
 628                                    routine is missing something.
 629                                 */
 630                                 printk(KERN_WARNING "Cannot make free space.\n");
 631                                 return BLOCK_NIL;
 632                         }
 633                         //printk("Restarting scan\n");
 634                         lastEUN = BLOCK_NIL;
 635                         continue;
 636                 }
 637
 638                 /* We've found a free block. Insert it into the chain. */
 639
 640                 if (lastEUN != BLOCK_NIL) {
 641                         thisVUC |= 0x8000; /* It's a replacement block */
 642                 } else {
 643                         /* The first block in a new chain */
 644                         nftl->EUNtable[thisVUC] = writeEUN;
 645                 }
 646
 647                 /* set up the actual EUN we're writing into */
 648                 /* Both in our cache... */
 649                 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
 650
 651                 /* ... and on the flash itself */
 652                 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
 653                               &retlen, (char *)&oob.u);
 654
 655                 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
 656
 657                 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
 658                                &retlen, (char *)&oob.u);
 659
 660                 /* we link the new block to the chain only after the
 661                    block is ready. It avoids the case where the chain
 662                    could point to a free block */
 663                 if (lastEUN != BLOCK_NIL) {
 664                         /* Both in our cache... */
 665                         nftl->ReplUnitTable[lastEUN] = writeEUN;
 666                         /* ... and on the flash itself */
 667                         nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
 668                                       8, &retlen, (char *)&oob.u);
 669
 670                         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
 671                                 = cpu_to_le16(writeEUN);
 672
 673                         nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
 674                                        8, &retlen, (char *)&oob.u);
 675                 }
 676
 677                 return writeEUN;
 678
 679         } while (silly2--);
 680
 681         printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
 682                thisVUC);
 683         return 0xffff;
 684 }
 685
 686 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 687                            char *buffer)
 688 {
 689         struct NFTLrecord *nftl = (void *)mbd;
 690         u16 writeEUN;
 691         unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
 692         size_t retlen;
 693         struct nftl_oob oob;
 694
 695         writeEUN = NFTL_findwriteunit(nftl, block);
 696
 697         if (writeEUN == BLOCK_NIL) {
 698                 printk(KERN_WARNING
 699                        "NFTL_writeblock(): Cannot find block to write to\n");
 700                 /* If we _still_ haven't got a block to use, we're screwed */
 701                 return 1;
 702         }
 703
 704         memset(&oob, 0xff, sizeof(struct nftl_oob));
 705         oob.b.Status = oob.b.Status1 = SECTOR_USED;
 706
 707         nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
 708                    512, &retlen, (char *)buffer, (char *)&oob);
 709         return 0;
 710 }
 711 #endif /* CONFIG_NFTL_RW */
 712
 713 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 714                           char *buffer)
 715 {
 716         struct NFTLrecord *nftl = (void *)mbd;
 717         struct mtd_info *mtd = nftl->mbd.mtd;
 718         u16 lastgoodEUN;
 719         u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
 720         unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
 721         unsigned int status;
 722         int silly = MAX_LOOPS;
 723         size_t retlen;
 724         struct nftl_bci bci;
 725
 726         lastgoodEUN = BLOCK_NIL;
 727
 728         if (thisEUN != BLOCK_NIL) {
 729                 while (thisEUN < nftl->nb_blocks) {
 730                         if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
 731                                           blockofs, 8, &retlen,
 732                                           (char *)&bci) < 0)
 733                                 status = SECTOR_IGNORE;
 734                         else
 735                                 status = bci.Status | bci.Status1;
 736
 737                         switch (status) {
 738                         case SECTOR_FREE:
 739                                 /* no modification of a sector should follow a free sector */
 740                                 goto the_end;
 741                         case SECTOR_DELETED:
 742                                 lastgoodEUN = BLOCK_NIL;
 743                                 break;
 744                         case SECTOR_USED:
 745                                 lastgoodEUN = thisEUN;
 746                                 break;
 747                         case SECTOR_IGNORE:
 748                                 break;
 749                         default:
 750                                 printk("Unknown status for block %ld in EUN %d: %x\n",
 751                                        block, thisEUN, status);
 752                                 break;
 753                         }
 754
 755                         if (!silly--) {
 756                                 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
 757                                        block / (nftl->EraseSize / 512));
 758                                 return 1;
 759                         }
 760                         thisEUN = nftl->ReplUnitTable[thisEUN];
 761                 }
 762         }
 763
 764  the_end:
 765         if (lastgoodEUN == BLOCK_NIL) {
 766                 /* the requested block is not on the media, return all 0x00 */
 767                 memset(buffer, 0, 512);
 768         } else {
 769                 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
 770                 size_t retlen;
 771                 int res = mtd->read(mtd, ptr, 512, &retlen, buffer);
 772
 773                 if (res < 0 && res != -EUCLEAN)
 774                         return -EIO;
 775         }
 776         return 0;
 777 }
 778
 779 static int nftl_getgeo(struct mtd_blktrans_dev *dev,  struct hd_geometry *geo)
 780 {
 781         struct NFTLrecord *nftl = (void *)dev;
 782
 783         geo->heads = nftl->heads;
 784         geo->sectors = nftl->sectors;
 785         geo->cylinders = nftl->cylinders;
 786
 787         return 0;
 788 }
 789
 790 /****************************************************************************
 791  *
 792  * Module stuff
 793  *
 794  ****************************************************************************/
 795
 796
 797 static struct mtd_blktrans_ops nftl_tr = {
 798         .name           = "nftl",
 799         .major          = NFTL_MAJOR,
 800         .part_bits      = NFTL_PARTN_BITS,
 801         .getgeo         = nftl_getgeo,
 802         .readsect       = nftl_readblock,
 803 #ifdef CONFIG_NFTL_RW
 804         .writesect      = nftl_writeblock,
 805 #endif
 806         .add_mtd        = nftl_add_mtd,
 807         .remove_dev     = nftl_remove_dev,
 808         .owner          = THIS_MODULE,
 809 };
 810
 811 extern char nftlmountrev[];
 812
 813 static int __init init_nftl(void)
 814 {
 815         printk(KERN_INFO "NFTL driver: nftlcore.c $Revision: 1.98 $, nftlmount.c %s\n", nftlmountrev);
 816
 817         return register_mtd_blktrans(&nftl_tr);
 818 }
 819
 820 static void __exit cleanup_nftl(void)
 821 {
 822         deregister_mtd_blktrans(&nftl_tr);
 823 }
 824
 825 module_init(init_nftl);
 826 module_exit(cleanup_nftl);
 827
 828 MODULE_LICENSE("GPL");
 829 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
 830 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");