drivers/mtd/nftlcore.c

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