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