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