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