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