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