drivers/mtd/inftlcore.c

   1 /*
   2  * inftlcore.c -- Linux driver for Inverse Flash Translation Layer (INFTL)
   3  *
   4  * (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
   5  *
   6  * Based heavily on the nftlcore.c code which is:
   7  * (c) 1999 Machine Vision Holdings, Inc.
   8  * Author: David Woodhouse <dwmw2@infradead.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/sched.h>
  30 #include <linux/init.h>
  31 #include <linux/kmod.h>
  32 #include <linux/hdreg.h>
  33 #include <linux/mtd/mtd.h>
  34 #include <linux/mtd/nftl.h>
  35 #include <linux/mtd/inftl.h>
  36 #include <linux/mtd/nand.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/errno.h>
  39 #include <asm/io.h>
  40
  41 /*
  42  * Maximum number of loops while examining next block, to have a
  43  * chance to detect consistency problems (they should never happen
  44  * because of the checks done in the mounting.
  45  */
  46 #define MAX_LOOPS 10000
  47
  48 static void inftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
  49 {
  50         struct INFTLrecord *inftl;
  51         unsigned long temp;
  52
  53         if (mtd->type != MTD_NANDFLASH || mtd->size > UINT_MAX)
  54                 return;
  55         /* OK, this is moderately ugly.  But probably safe.  Alternatives? */
  56         if (memcmp(mtd->name, "DiskOnChip", 10))
  57                 return;
  58
  59         if (!mtd->block_isbad) {
  60                 printk(KERN_ERR
  61 "INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
  62 "Please use the new diskonchip driver under the NAND subsystem.\n");
  63                 return;
  64         }
  65
  66         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: add_mtd for %s\n", mtd->name);
  67
  68         inftl = kzalloc(sizeof(*inftl), GFP_KERNEL);
  69
  70         if (!inftl) {
  71                 printk(KERN_WARNING "INFTL: Out of memory for data structures\n");
  72                 return;
  73         }
  74
  75         inftl->mbd.mtd = mtd;
  76         inftl->mbd.devnum = -1;
  77
  78         inftl->mbd.tr = tr;
  79
  80         if (INFTL_mount(inftl) < 0) {
  81                 printk(KERN_WARNING "INFTL: could not mount device\n");
  82                 kfree(inftl);
  83                 return;
  84         }
  85
  86         /* OK, it's a new one. Set up all the data structures. */
  87
  88         /* Calculate geometry */
  89         inftl->cylinders = 1024;
  90         inftl->heads = 16;
  91
  92         temp = inftl->cylinders * inftl->heads;
  93         inftl->sectors = inftl->mbd.size / temp;
  94         if (inftl->mbd.size % temp) {
  95                 inftl->sectors++;
  96                 temp = inftl->cylinders * inftl->sectors;
  97                 inftl->heads = inftl->mbd.size / temp;
  98
  99                 if (inftl->mbd.size % temp) {
 100                         inftl->heads++;
 101                         temp = inftl->heads * inftl->sectors;
 102                         inftl->cylinders = inftl->mbd.size / temp;
 103                 }
 104         }
 105
 106         if (inftl->mbd.size != inftl->heads * inftl->cylinders * inftl->sectors) {
 107                 /*
 108                   Oh no we don't have
 109                    mbd.size == heads * cylinders * sectors
 110                 */
 111                 printk(KERN_WARNING "INFTL: cannot calculate a geometry to "
 112                        "match size of 0x%lx.\n", inftl->mbd.size);
 113                 printk(KERN_WARNING "INFTL: using C:%d H:%d S:%d "
 114                         "(== 0x%lx sects)\n",
 115                         inftl->cylinders, inftl->heads , inftl->sectors,
 116                         (long)inftl->cylinders * (long)inftl->heads *
 117                         (long)inftl->sectors );
 118         }
 119
 120         if (add_mtd_blktrans_dev(&inftl->mbd)) {
 121                 kfree(inftl->PUtable);
 122                 kfree(inftl->VUtable);
 123                 kfree(inftl);
 124                 return;
 125         }
 126 #ifdef PSYCHO_DEBUG
 127         printk(KERN_INFO "INFTL: Found new inftl%c\n", inftl->mbd.devnum + 'a');
 128 #endif
 129         return;
 130 }
 131
 132 static void inftl_remove_dev(struct mtd_blktrans_dev *dev)
 133 {
 134         struct INFTLrecord *inftl = (void *)dev;
 135
 136         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: remove_dev (i=%d)\n", dev->devnum);
 137
 138         del_mtd_blktrans_dev(dev);
 139
 140         kfree(inftl->PUtable);
 141         kfree(inftl->VUtable);
 142         kfree(inftl);
 143 }
 144
 145 /*
 146  * Actual INFTL access routines.
 147  */
 148
 149 /*
 150  * Read oob data from flash
 151  */
 152 int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
 153                    size_t *retlen, uint8_t *buf)
 154 {
 155         struct mtd_oob_ops ops;
 156         int res;
 157
 158         ops.mode = MTD_OOB_PLACE;
 159         ops.ooboffs = offs & (mtd->writesize - 1);
 160         ops.ooblen = len;
 161         ops.oobbuf = buf;
 162         ops.datbuf = NULL;
 163
 164         res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 165         *retlen = ops.oobretlen;
 166         return res;
 167 }
 168
 169 /*
 170  * Write oob data to flash
 171  */
 172 int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
 173                     size_t *retlen, uint8_t *buf)
 174 {
 175         struct mtd_oob_ops ops;
 176         int res;
 177
 178         ops.mode = MTD_OOB_PLACE;
 179         ops.ooboffs = offs & (mtd->writesize - 1);
 180         ops.ooblen = len;
 181         ops.oobbuf = buf;
 182         ops.datbuf = NULL;
 183
 184         res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 185         *retlen = ops.oobretlen;
 186         return res;
 187 }
 188
 189 /*
 190  * Write data and oob to flash
 191  */
 192 static int inftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
 193                        size_t *retlen, uint8_t *buf, uint8_t *oob)
 194 {
 195         struct mtd_oob_ops ops;
 196         int res;
 197
 198         ops.mode = MTD_OOB_PLACE;
 199         ops.ooboffs = offs;
 200         ops.ooblen = mtd->oobsize;
 201         ops.oobbuf = oob;
 202         ops.datbuf = buf;
 203         ops.len = len;
 204
 205         res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
 206         *retlen = ops.retlen;
 207         return res;
 208 }
 209
 210 /*
 211  * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
 212  *      This function is used when the give Virtual Unit Chain.
 213  */
 214 static u16 INFTL_findfreeblock(struct INFTLrecord *inftl, int desperate)
 215 {
 216         u16 pot = inftl->LastFreeEUN;
 217         int silly = inftl->nb_blocks;
 218
 219         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_findfreeblock(inftl=%p,"
 220                 "desperate=%d)\n", inftl, desperate);
 221
 222         /*
 223          * Normally, we force a fold to happen before we run out of free
 224          * blocks completely.
 225          */
 226         if (!desperate && inftl->numfreeEUNs < 2) {
 227                 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: there are too few free "
 228                         "EUNs (%d)\n", inftl->numfreeEUNs);
 229                 return BLOCK_NIL;
 230         }
 231
 232         /* Scan for a free block */
 233         do {
 234                 if (inftl->PUtable[pot] == BLOCK_FREE) {
 235                         inftl->LastFreeEUN = pot;
 236                         return pot;
 237                 }
 238
 239                 if (++pot > inftl->lastEUN)
 240                         pot = 0;
 241
 242                 if (!silly--) {
 243                         printk(KERN_WARNING "INFTL: no free blocks found!  "
 244                                 "EUN range = %d - %d\n", 0, inftl->LastFreeEUN);
 245                         return BLOCK_NIL;
 246                 }
 247         } while (pot != inftl->LastFreeEUN);
 248
 249         return BLOCK_NIL;
 250 }
 251
 252 static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned pendingblock)
 253 {
 254         u16 BlockMap[MAX_SECTORS_PER_UNIT];
 255         unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
 256         unsigned int thisEUN, prevEUN, status;
 257         struct mtd_info *mtd = inftl->mbd.mtd;
 258         int block, silly;
 259         unsigned int targetEUN;
 260         struct inftl_oob oob;
 261         size_t retlen;
 262
 263         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,"
 264                 "pending=%d)\n", inftl, thisVUC, pendingblock);
 265
 266         memset(BlockMap, 0xff, sizeof(BlockMap));
 267         memset(BlockDeleted, 0, sizeof(BlockDeleted));
 268
 269         thisEUN = targetEUN = inftl->VUtable[thisVUC];
 270
 271         if (thisEUN == BLOCK_NIL) {
 272                 printk(KERN_WARNING "INFTL: trying to fold non-existent "
 273                        "Virtual Unit Chain %d!\n", thisVUC);
 274                 return BLOCK_NIL;
 275         }
 276
 277         /*
 278          * Scan to find the Erase Unit which holds the actual data for each
 279          * 512-byte block within the Chain.
 280          */
 281         silly = MAX_LOOPS;
 282         while (thisEUN < inftl->nb_blocks) {
 283                 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) {
 284                         if ((BlockMap[block] != BLOCK_NIL) ||
 285                             BlockDeleted[block])
 286                                 continue;
 287
 288                         if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
 289                                            + (block * SECTORSIZE), 16, &retlen,
 290                                            (char *)&oob) < 0)
 291                                 status = SECTOR_IGNORE;
 292                         else
 293                                 status = oob.b.Status | oob.b.Status1;
 294
 295                         switch(status) {
 296                         case SECTOR_FREE:
 297                         case SECTOR_IGNORE:
 298                                 break;
 299                         case SECTOR_USED:
 300                                 BlockMap[block] = thisEUN;
 301                                 continue;
 302                         case SECTOR_DELETED:
 303                                 BlockDeleted[block] = 1;
 304                                 continue;
 305                         default:
 306                                 printk(KERN_WARNING "INFTL: unknown status "
 307                                         "for block %d in EUN %d: %x\n",
 308                                         block, thisEUN, status);
 309                                 break;
 310                         }
 311                 }
 312
 313                 if (!silly--) {
 314                         printk(KERN_WARNING "INFTL: infinite loop in Virtual "
 315                                 "Unit Chain 0x%x\n", thisVUC);
 316                         return BLOCK_NIL;
 317                 }
 318
 319                 thisEUN = inftl->PUtable[thisEUN];
 320         }
 321
 322         /*
 323          * OK. We now know the location of every block in the Virtual Unit
 324          * Chain, and the Erase Unit into which we are supposed to be copying.
 325          * Go for it.
 326          */
 327         DEBUG(MTD_DEBUG_LEVEL1, "INFTL: folding chain %d into unit %d\n",
 328                 thisVUC, targetEUN);
 329
 330         for (block = 0; block < inftl->EraseSize/SECTORSIZE ; block++) {
 331                 unsigned char movebuf[SECTORSIZE];
 332                 int ret;
 333
 334                 /*
 335                  * If it's in the target EUN already, or if it's pending write,
 336                  * do nothing.
 337                  */
 338                 if (BlockMap[block] == targetEUN || (pendingblock ==
 339                     (thisVUC * (inftl->EraseSize / SECTORSIZE) + block))) {
 340                         continue;
 341                 }
 342
 343                 /*
 344                  * Copy only in non free block (free blocks can only
 345                  * happen in case of media errors or deleted blocks).
 346                  */
 347                 if (BlockMap[block] == BLOCK_NIL)
 348                         continue;
 349
 350                 ret = mtd->read(mtd, (inftl->EraseSize * BlockMap[block]) +
 351                                 (block * SECTORSIZE), SECTORSIZE, &retlen,
 352                                 movebuf);
 353                 if (ret < 0 && ret != -EUCLEAN) {
 354                         ret = mtd->read(mtd,
 355                                         (inftl->EraseSize * BlockMap[block]) +
 356                                         (block * SECTORSIZE), SECTORSIZE,
 357                                         &retlen, movebuf);
 358                         if (ret != -EIO)
 359                                 DEBUG(MTD_DEBUG_LEVEL1, "INFTL: error went "
 360                                       "away on retry?\n");
 361                 }
 362                 memset(&oob, 0xff, sizeof(struct inftl_oob));
 363                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
 364
 365                 inftl_write(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) +
 366                             (block * SECTORSIZE), SECTORSIZE, &retlen,
 367                             movebuf, (char *)&oob);
 368         }
 369
 370         /*
 371          * Newest unit in chain now contains data from _all_ older units.
 372          * So go through and erase each unit in chain, oldest first. (This
 373          * is important, by doing oldest first if we crash/reboot then it
 374          * it is relatively simple to clean up the mess).
 375          */
 376         DEBUG(MTD_DEBUG_LEVEL1, "INFTL: want to erase virtual chain %d\n",
 377                 thisVUC);
 378
 379         for (;;) {
 380                 /* Find oldest unit in chain. */
 381                 thisEUN = inftl->VUtable[thisVUC];
 382                 prevEUN = BLOCK_NIL;
 383                 while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
 384                         prevEUN = thisEUN;
 385                         thisEUN = inftl->PUtable[thisEUN];
 386                 }
 387
 388                 /* Check if we are all done */
 389                 if (thisEUN == targetEUN)
 390                         break;
 391
 392                 /* Unlink the last block from the chain. */
 393                 inftl->PUtable[prevEUN] = BLOCK_NIL;
 394
 395                 /* Now try to erase it. */
 396                 if (INFTL_formatblock(inftl, thisEUN) < 0) {
 397                         /*
 398                          * Could not erase : mark block as reserved.
 399                          */
 400                         inftl->PUtable[thisEUN] = BLOCK_RESERVED;
 401                 } else {
 402                         /* Correctly erased : mark it as free */
 403                         inftl->PUtable[thisEUN] = BLOCK_FREE;
 404                         inftl->numfreeEUNs++;
 405                 }
 406         }
 407
 408         return targetEUN;
 409 }
 410
 411 static u16 INFTL_makefreeblock(struct INFTLrecord *inftl, unsigned pendingblock)
 412 {
 413         /*
 414          * This is the part that needs some cleverness applied.
 415          * For now, I'm doing the minimum applicable to actually
 416          * get the thing to work.
 417          * Wear-levelling and other clever stuff needs to be implemented
 418          * and we also need to do some assessment of the results when
 419          * the system loses power half-way through the routine.
 420          */
 421         u16 LongestChain = 0;
 422         u16 ChainLength = 0, thislen;
 423         u16 chain, EUN;
 424
 425         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_makefreeblock(inftl=%p,"
 426                 "pending=%d)\n", inftl, pendingblock);
 427
 428         for (chain = 0; chain < inftl->nb_blocks; chain++) {
 429                 EUN = inftl->VUtable[chain];
 430                 thislen = 0;
 431
 432                 while (EUN <= inftl->lastEUN) {
 433                         thislen++;
 434                         EUN = inftl->PUtable[EUN];
 435                         if (thislen > 0xff00) {
 436                                 printk(KERN_WARNING "INFTL: endless loop in "
 437                                         "Virtual Chain %d: Unit %x\n",
 438                                         chain, EUN);
 439                                 /*
 440                                  * Actually, don't return failure.
 441                                  * Just ignore this chain and get on with it.
 442                                  */
 443                                 thislen = 0;
 444                                 break;
 445                         }
 446                 }
 447
 448                 if (thislen > ChainLength) {
 449                         ChainLength = thislen;
 450                         LongestChain = chain;
 451                 }
 452         }
 453
 454         if (ChainLength < 2) {
 455                 printk(KERN_WARNING "INFTL: no Virtual Unit Chains available "
 456                         "for folding. Failing request\n");
 457                 return BLOCK_NIL;
 458         }
 459
 460         return INFTL_foldchain(inftl, LongestChain, pendingblock);
 461 }
 462
 463 static int nrbits(unsigned int val, int bitcount)
 464 {
 465         int i, total = 0;
 466
 467         for (i = 0; (i < bitcount); i++)
 468                 total += (((0x1 << i) & val) ? 1 : 0);
 469         return total;
 470 }
 471
 472 /*
 473  * INFTL_findwriteunit: Return the unit number into which we can write
 474  *                      for this block. Make it available if it isn't already.
 475  */
 476 static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
 477 {
 478         unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE);
 479         unsigned int thisEUN, writeEUN, prev_block, status;
 480         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1);
 481         struct mtd_info *mtd = inftl->mbd.mtd;
 482         struct inftl_oob oob;
 483         struct inftl_bci bci;
 484         unsigned char anac, nacs, parity;
 485         size_t retlen;
 486         int silly, silly2 = 3;
 487
 488         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_findwriteunit(inftl=%p,"
 489                 "block=%d)\n", inftl, block);
 490
 491         do {
 492                 /*
 493                  * Scan the media to find a unit in the VUC which has
 494                  * a free space for the block in question.
 495                  */
 496                 writeEUN = BLOCK_NIL;
 497                 thisEUN = inftl->VUtable[thisVUC];
 498                 silly = MAX_LOOPS;
 499
 500                 while (thisEUN <= inftl->lastEUN) {
 501                         inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
 502                                        blockofs, 8, &retlen, (char *)&bci);
 503
 504                         status = bci.Status | bci.Status1;
 505                         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: status of block %d in "
 506                                 "EUN %d is %x\n", block , writeEUN, status);
 507
 508                         switch(status) {
 509                         case SECTOR_FREE:
 510                                 writeEUN = thisEUN;
 511                                 break;
 512                         case SECTOR_DELETED:
 513                         case SECTOR_USED:
 514                                 /* Can't go any further */
 515                                 goto hitused;
 516                         case SECTOR_IGNORE:
 517                                 break;
 518                         default:
 519                                 /*
 520                                  * Invalid block. Don't use it any more.
 521                                  * Must implement.
 522                                  */
 523                                 break;
 524                         }
 525
 526                         if (!silly--) {
 527                                 printk(KERN_WARNING "INFTL: infinite loop in "
 528                                         "Virtual Unit Chain 0x%x\n", thisVUC);
 529                                 return BLOCK_NIL;
 530                         }
 531
 532                         /* Skip to next block in chain */
 533                         thisEUN = inftl->PUtable[thisEUN];
 534                 }
 535
 536 hitused:
 537                 if (writeEUN != BLOCK_NIL)
 538                         return writeEUN;
 539
 540
 541                 /*
 542                  * OK. We didn't find one in the existing chain, or there
 543                  * is no existing chain. Allocate a new one.
 544                  */
 545                 writeEUN = INFTL_findfreeblock(inftl, 0);
 546
 547                 if (writeEUN == BLOCK_NIL) {
 548                         /*
 549                          * That didn't work - there were no free blocks just
 550                          * waiting to be picked up. We're going to have to fold
 551                          * a chain to make room.
 552                          */
 553                         thisEUN = INFTL_makefreeblock(inftl, block);
 554
 555                         /*
 556                          * Hopefully we free something, lets try again.
 557                          * This time we are desperate...
 558                          */
 559                         DEBUG(MTD_DEBUG_LEVEL1, "INFTL: using desperate==1 "
 560                                 "to find free EUN to accommodate write to "
 561                                 "VUC %d\n", thisVUC);
 562                         writeEUN = INFTL_findfreeblock(inftl, 1);
 563                         if (writeEUN == BLOCK_NIL) {
 564                                 /*
 565                                  * Ouch. This should never happen - we should
 566                                  * always be able to make some room somehow.
 567                                  * If we get here, we've allocated more storage
 568                                  * space than actual media, or our makefreeblock
 569                                  * routine is missing something.
 570                                  */
 571                                 printk(KERN_WARNING "INFTL: cannot make free "
 572                                         "space.\n");
 573 #ifdef DEBUG
 574                                 INFTL_dumptables(inftl);
 575                                 INFTL_dumpVUchains(inftl);
 576 #endif
 577                                 return BLOCK_NIL;
 578                         }
 579                 }
 580
 581                 /*
 582                  * Insert new block into virtual chain. Firstly update the
 583                  * block headers in flash...
 584                  */
 585                 anac = 0;
 586                 nacs = 0;
 587                 thisEUN = inftl->VUtable[thisVUC];
 588                 if (thisEUN != BLOCK_NIL) {
 589                         inftl_read_oob(mtd, thisEUN * inftl->EraseSize
 590                                        + 8, 8, &retlen, (char *)&oob.u);
 591                         anac = oob.u.a.ANAC + 1;
 592                         nacs = oob.u.a.NACs + 1;
 593                 }
 594
 595                 prev_block = inftl->VUtable[thisVUC];
 596                 if (prev_block < inftl->nb_blocks)
 597                         prev_block -= inftl->firstEUN;
 598
 599                 parity = (nrbits(thisVUC, 16) & 0x1) ? 0x1 : 0;
 600                 parity |= (nrbits(prev_block, 16) & 0x1) ? 0x2 : 0;
 601                 parity |= (nrbits(anac, 8) & 0x1) ? 0x4 : 0;
 602                 parity |= (nrbits(nacs, 8) & 0x1) ? 0x8 : 0;
 603
 604                 oob.u.a.virtualUnitNo = cpu_to_le16(thisVUC);
 605                 oob.u.a.prevUnitNo = cpu_to_le16(prev_block);
 606                 oob.u.a.ANAC = anac;
 607                 oob.u.a.NACs = nacs;
 608                 oob.u.a.parityPerField = parity;
 609                 oob.u.a.discarded = 0xaa;
 610
 611                 inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 8, 8,
 612                                 &retlen, (char *)&oob.u);
 613
 614                 /* Also back up header... */
 615                 oob.u.b.virtualUnitNo = cpu_to_le16(thisVUC);
 616                 oob.u.b.prevUnitNo = cpu_to_le16(prev_block);
 617                 oob.u.b.ANAC = anac;
 618                 oob.u.b.NACs = nacs;
 619                 oob.u.b.parityPerField = parity;
 620                 oob.u.b.discarded = 0xaa;
 621
 622                 inftl_write_oob(mtd, writeEUN * inftl->EraseSize +
 623                                 SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u);
 624
 625                 inftl->PUtable[writeEUN] = inftl->VUtable[thisVUC];
 626                 inftl->VUtable[thisVUC] = writeEUN;
 627
 628                 inftl->numfreeEUNs--;
 629                 return writeEUN;
 630
 631         } while (silly2--);
 632
 633         printk(KERN_WARNING "INFTL: error folding to make room for Virtual "
 634                 "Unit Chain 0x%x\n", thisVUC);
 635         return BLOCK_NIL;
 636 }
 637
 638 /*
 639  * Given a Virtual Unit Chain, see if it can be deleted, and if so do it.
 640  */
 641 static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
 642 {
 643         struct mtd_info *mtd = inftl->mbd.mtd;
 644         unsigned char BlockUsed[MAX_SECTORS_PER_UNIT];
 645         unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
 646         unsigned int thisEUN, status;
 647         int block, silly;
 648         struct inftl_bci bci;
 649         size_t retlen;
 650
 651         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_trydeletechain(inftl=%p,"
 652                 "thisVUC=%d)\n", inftl, thisVUC);
 653
 654         memset(BlockUsed, 0, sizeof(BlockUsed));
 655         memset(BlockDeleted, 0, sizeof(BlockDeleted));
 656
 657         thisEUN = inftl->VUtable[thisVUC];
 658         if (thisEUN == BLOCK_NIL) {
 659                 printk(KERN_WARNING "INFTL: trying to delete non-existent "
 660                        "Virtual Unit Chain %d!\n", thisVUC);
 661                 return;
 662         }
 663
 664         /*
 665          * Scan through the Erase Units to determine whether any data is in
 666          * each of the 512-byte blocks within the Chain.
 667          */
 668         silly = MAX_LOOPS;
 669         while (thisEUN < inftl->nb_blocks) {
 670                 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) {
 671                         if (BlockUsed[block] || BlockDeleted[block])
 672                                 continue;
 673
 674                         if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
 675                                            + (block * SECTORSIZE), 8 , &retlen,
 676                                           (char *)&bci) < 0)
 677                                 status = SECTOR_IGNORE;
 678                         else
 679                                 status = bci.Status | bci.Status1;
 680
 681                         switch(status) {
 682                         case SECTOR_FREE:
 683                         case SECTOR_IGNORE:
 684                                 break;
 685                         case SECTOR_USED:
 686                                 BlockUsed[block] = 1;
 687                                 continue;
 688                         case SECTOR_DELETED:
 689                                 BlockDeleted[block] = 1;
 690                                 continue;
 691                         default:
 692                                 printk(KERN_WARNING "INFTL: unknown status "
 693                                         "for block %d in EUN %d: 0x%x\n",
 694                                         block, thisEUN, status);
 695                         }
 696                 }
 697
 698                 if (!silly--) {
 699                         printk(KERN_WARNING "INFTL: infinite loop in Virtual "
 700                                 "Unit Chain 0x%x\n", thisVUC);
 701                         return;
 702                 }
 703
 704                 thisEUN = inftl->PUtable[thisEUN];
 705         }
 706
 707         for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++)
 708                 if (BlockUsed[block])
 709                         return;
 710
 711         /*
 712          * For each block in the chain free it and make it available
 713          * for future use. Erase from the oldest unit first.
 714          */
 715         DEBUG(MTD_DEBUG_LEVEL1, "INFTL: deleting empty VUC %d\n", thisVUC);
 716
 717         for (;;) {
 718                 u16 *prevEUN = &inftl->VUtable[thisVUC];
 719                 thisEUN = *prevEUN;
 720
 721                 /* If the chain is all gone already, we're done */
 722                 if (thisEUN == BLOCK_NIL) {
 723                         DEBUG(MTD_DEBUG_LEVEL2, "INFTL: Empty VUC %d for deletion was already absent\n", thisEUN);
 724                         return;
 725                 }
 726
 727                 /* Find oldest unit in chain. */
 728                 while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
 729                         BUG_ON(thisEUN >= inftl->nb_blocks);
 730
 731                         prevEUN = &inftl->PUtable[thisEUN];
 732                         thisEUN = *prevEUN;
 733                 }
 734
 735                 DEBUG(MTD_DEBUG_LEVEL3, "Deleting EUN %d from VUC %d\n",
 736                       thisEUN, thisVUC);
 737
 738                 if (INFTL_formatblock(inftl, thisEUN) < 0) {
 739                         /*
 740                          * Could not erase : mark block as reserved.
 741                          */
 742                         inftl->PUtable[thisEUN] = BLOCK_RESERVED;
 743                 } else {
 744                         /* Correctly erased : mark it as free */
 745                         inftl->PUtable[thisEUN] = BLOCK_FREE;
 746                         inftl->numfreeEUNs++;
 747                 }
 748
 749                 /* Now sort out whatever was pointing to it... */
 750                 *prevEUN = BLOCK_NIL;
 751
 752                 /* Ideally we'd actually be responsive to new
 753                    requests while we're doing this -- if there's
 754                    free space why should others be made to wait? */
 755                 cond_resched();
 756         }
 757
 758         inftl->VUtable[thisVUC] = BLOCK_NIL;
 759 }
 760
 761 static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block)
 762 {
 763         unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
 764         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
 765         struct mtd_info *mtd = inftl->mbd.mtd;
 766         unsigned int status;
 767         int silly = MAX_LOOPS;
 768         size_t retlen;
 769         struct inftl_bci bci;
 770
 771         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: INFTL_deleteblock(inftl=%p,"
 772                 "block=%d)\n", inftl, block);
 773
 774         while (thisEUN < inftl->nb_blocks) {
 775                 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
 776                                    blockofs, 8, &retlen, (char *)&bci) < 0)
 777                         status = SECTOR_IGNORE;
 778                 else
 779                         status = bci.Status | bci.Status1;
 780
 781                 switch (status) {
 782                 case SECTOR_FREE:
 783                 case SECTOR_IGNORE:
 784                         break;
 785                 case SECTOR_DELETED:
 786                         thisEUN = BLOCK_NIL;
 787                         goto foundit;
 788                 case SECTOR_USED:
 789                         goto foundit;
 790                 default:
 791                         printk(KERN_WARNING "INFTL: unknown status for "
 792                                 "block %d in EUN %d: 0x%x\n",
 793                                 block, thisEUN, status);
 794                         break;
 795                 }
 796
 797                 if (!silly--) {
 798                         printk(KERN_WARNING "INFTL: infinite loop in Virtual "
 799                                 "Unit Chain 0x%x\n",
 800                                 block / (inftl->EraseSize / SECTORSIZE));
 801                         return 1;
 802                 }
 803                 thisEUN = inftl->PUtable[thisEUN];
 804         }
 805
 806 foundit:
 807         if (thisEUN != BLOCK_NIL) {
 808                 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
 809
 810                 if (inftl_read_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
 811                         return -EIO;
 812                 bci.Status = bci.Status1 = SECTOR_DELETED;
 813                 if (inftl_write_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
 814                         return -EIO;
 815                 INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE));
 816         }
 817         return 0;
 818 }
 819
 820 static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 821                             char *buffer)
 822 {
 823         struct INFTLrecord *inftl = (void *)mbd;
 824         unsigned int writeEUN;
 825         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
 826         size_t retlen;
 827         struct inftl_oob oob;
 828         char *p, *pend;
 829
 830         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: inftl_writeblock(inftl=%p,block=%ld,"
 831                 "buffer=%p)\n", inftl, block, buffer);
 832
 833         /* Is block all zero? */
 834         pend = buffer + SECTORSIZE;
 835         for (p = buffer; p < pend && !*p; p++)
 836                 ;
 837
 838         if (p < pend) {
 839                 writeEUN = INFTL_findwriteunit(inftl, block);
 840
 841                 if (writeEUN == BLOCK_NIL) {
 842                         printk(KERN_WARNING "inftl_writeblock(): cannot find "
 843                                 "block to write to\n");
 844                         /*
 845                          * If we _still_ haven't got a block to use,
 846                          * we're screwed.
 847                          */
 848                         return 1;
 849                 }
 850
 851                 memset(&oob, 0xff, sizeof(struct inftl_oob));
 852                 oob.b.Status = oob.b.Status1 = SECTOR_USED;
 853
 854                 inftl_write(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) +
 855                             blockofs, SECTORSIZE, &retlen, (char *)buffer,
 856                             (char *)&oob);
 857                 /*
 858                  * need to write SECTOR_USED flags since they are not written
 859                  * in mtd_writeecc
 860                  */
 861         } else {
 862                 INFTL_deleteblock(inftl, block);
 863         }
 864
 865         return 0;
 866 }
 867
 868 static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
 869                            char *buffer)
 870 {
 871         struct INFTLrecord *inftl = (void *)mbd;
 872         unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
 873         unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
 874         struct mtd_info *mtd = inftl->mbd.mtd;
 875         unsigned int status;
 876         int silly = MAX_LOOPS;
 877         struct inftl_bci bci;
 878         size_t retlen;
 879
 880         DEBUG(MTD_DEBUG_LEVEL3, "INFTL: inftl_readblock(inftl=%p,block=%ld,"
 881                 "buffer=%p)\n", inftl, block, buffer);
 882
 883         while (thisEUN < inftl->nb_blocks) {
 884                 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
 885                                   blockofs, 8, &retlen, (char *)&bci) < 0)
 886                         status = SECTOR_IGNORE;
 887                 else
 888                         status = bci.Status | bci.Status1;
 889
 890                 switch (status) {
 891                 case SECTOR_DELETED:
 892                         thisEUN = BLOCK_NIL;
 893                         goto foundit;
 894                 case SECTOR_USED:
 895                         goto foundit;
 896                 case SECTOR_FREE:
 897                 case SECTOR_IGNORE:
 898                         break;
 899                 default:
 900                         printk(KERN_WARNING "INFTL: unknown status for "
 901                                 "block %ld in EUN %d: 0x%04x\n",
 902                                 block, thisEUN, status);
 903                         break;
 904                 }
 905
 906                 if (!silly--) {
 907                         printk(KERN_WARNING "INFTL: infinite loop in "
 908                                 "Virtual Unit Chain 0x%lx\n",
 909                                 block / (inftl->EraseSize / SECTORSIZE));
 910                         return 1;
 911                 }
 912
 913                 thisEUN = inftl->PUtable[thisEUN];
 914         }
 915
 916 foundit:
 917         if (thisEUN == BLOCK_NIL) {
 918                 /* The requested block is not on the media, return all 0x00 */
 919                 memset(buffer, 0, SECTORSIZE);
 920         } else {
 921                 size_t retlen;
 922                 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
 923                 int ret = mtd->read(mtd, ptr, SECTORSIZE, &retlen, buffer);
 924
 925                 /* Handle corrected bit flips gracefully */
 926                 if (ret < 0 && ret != -EUCLEAN)
 927                         return -EIO;
 928         }
 929         return 0;
 930 }
 931
 932 static int inftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
 933 {
 934         struct INFTLrecord *inftl = (void *)dev;
 935
 936         geo->heads = inftl->heads;
 937         geo->sectors = inftl->sectors;
 938         geo->cylinders = inftl->cylinders;
 939
 940         return 0;
 941 }
 942
 943 static struct mtd_blktrans_ops inftl_tr = {
 944         .name           = "inftl",
 945         .major          = INFTL_MAJOR,
 946         .part_bits      = INFTL_PARTN_BITS,
 947         .blksize        = 512,
 948         .getgeo         = inftl_getgeo,
 949         .readsect       = inftl_readblock,
 950         .writesect      = inftl_writeblock,
 951         .add_mtd        = inftl_add_mtd,
 952         .remove_dev     = inftl_remove_dev,
 953         .owner          = THIS_MODULE,
 954 };
 955
 956 static int __init init_inftl(void)
 957 {
 958         return register_mtd_blktrans(&inftl_tr);
 959 }
 960
 961 static void __exit cleanup_inftl(void)
 962 {
 963         deregister_mtd_blktrans(&inftl_tr);
 964 }
 965
 966 module_init(init_inftl);
 967 module_exit(cleanup_inftl);
 968
 969 MODULE_LICENSE("GPL");
 970 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
 971 MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus");