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