drivers/mtd/nftlmount.c

   1 /*
   2  * NFTL mount code with extensive checks
   3  *
   4  * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
   5  * Copyright (C) 2000 Netgem S.A.
   6  *
   7  * $Id: nftlmount.c,v 1.41 2005/11/07 11:14:21 gleixner Exp $
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <asm/errno.h>
  26 #include <linux/delay.h>
  27 #include <linux/slab.h>
  28 #include <linux/mtd/mtd.h>
  29 #include <linux/mtd/nand.h>
  30 #include <linux/mtd/nftl.h>
  31
  32 #define SECTORSIZE 512
  33
  34 char nftlmountrev[]="$Revision: 1.41 $";
  35
  36 extern int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
  37                          size_t *retlen, uint8_t *buf);
  38 extern int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
  39                           size_t *retlen, uint8_t *buf);
  40
  41 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
  42  *      various device information of the NFTL partition and Bad Unit Table. Update
  43  *      the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
  44  *      is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
  45  */
  46 static int find_boot_record(struct NFTLrecord *nftl)
  47 {
  48         struct nftl_uci1 h1;
  49         unsigned int block, boot_record_count = 0;
  50         size_t retlen;
  51         u8 buf[SECTORSIZE];
  52         struct NFTLMediaHeader *mh = &nftl->MediaHdr;
  53         struct mtd_info *mtd = nftl->mbd.mtd;
  54         unsigned int i;
  55
  56         /* Assume logical EraseSize == physical erasesize for starting the scan.
  57            We'll sort it out later if we find a MediaHeader which says otherwise */
  58         /* Actually, we won't.  The new DiskOnChip driver has already scanned
  59            the MediaHeader and adjusted the virtual erasesize it presents in
  60            the mtd device accordingly.  We could even get rid of
  61            nftl->EraseSize if there were any point in doing so. */
  62         nftl->EraseSize = nftl->mbd.mtd->erasesize;
  63         nftl->nb_blocks = nftl->mbd.mtd->size / nftl->EraseSize;
  64
  65         nftl->MediaUnit = BLOCK_NIL;
  66         nftl->SpareMediaUnit = BLOCK_NIL;
  67
  68         /* search for a valid boot record */
  69         for (block = 0; block < nftl->nb_blocks; block++) {
  70                 int ret;
  71
  72                 /* Check for ANAND header first. Then can whinge if it's found but later
  73                    checks fail */
  74                 ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
  75                                 &retlen, buf);
  76                 /* We ignore ret in case the ECC of the MediaHeader is invalid
  77                    (which is apparently acceptable) */
  78                 if (retlen != SECTORSIZE) {
  79                         static int warncount = 5;
  80
  81                         if (warncount) {
  82                                 printk(KERN_WARNING "Block read at 0x%x of mtd%d failed: %d\n",
  83                                        block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
  84                                 if (!--warncount)
  85                                         printk(KERN_WARNING "Further failures for this block will not be printed\n");
  86                         }
  87                         continue;
  88                 }
  89
  90                 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
  91                         /* ANAND\0 not found. Continue */
  92 #if 0
  93                         printk(KERN_DEBUG "ANAND header not found at 0x%x in mtd%d\n",
  94                                block * nftl->EraseSize, nftl->mbd.mtd->index);
  95 #endif
  96                         continue;
  97                 }
  98
  99                 /* To be safer with BIOS, also use erase mark as discriminant */
 100                 if ((ret = nftl_read_oob(mtd, block * nftl->EraseSize +
 101                                          SECTORSIZE + 8, 8, &retlen,
 102                                          (char *)&h1) < 0)) {
 103                         printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
 104                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
 105                         continue;
 106                 }
 107
 108 #if 0 /* Some people seem to have devices without ECC or erase marks
 109          on the Media Header blocks. There are enough other sanity
 110          checks in here that we can probably do without it.
 111       */
 112                 if (le16_to_cpu(h1.EraseMark | h1.EraseMark1) != ERASE_MARK) {
 113                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but erase mark not present (0x%04x,0x%04x instead)\n",
 114                                block * nftl->EraseSize, nftl->mbd.mtd->index,
 115                                le16_to_cpu(h1.EraseMark), le16_to_cpu(h1.EraseMark1));
 116                         continue;
 117                 }
 118
 119                 /* Finally reread to check ECC */
 120                 if ((ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
 121                                      &retlen, buf) < 0)) {
 122                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
 123                                block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
 124                         continue;
 125                 }
 126
 127                 /* Paranoia. Check the ANAND header is still there after the ECC read */
 128                 if (memcmp(buf, "ANAND", 6)) {
 129                         printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but went away on reread!\n",
 130                                block * nftl->EraseSize, nftl->mbd.mtd->index);
 131                         printk(KERN_NOTICE "New data are: %02x %02x %02x %02x %02x %02x\n",
 132                                buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 133                         continue;
 134                 }
 135 #endif
 136                 /* OK, we like it. */
 137
 138                 if (boot_record_count) {
 139                         /* We've already processed one. So we just check if
 140                            this one is the same as the first one we found */
 141                         if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
 142                                 printk(KERN_NOTICE "NFTL Media Headers at 0x%x and 0x%x disagree.\n",
 143                                        nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
 144                                 /* if (debug) Print both side by side */
 145                                 if (boot_record_count < 2) {
 146                                         /* We haven't yet seen two real ones */
 147                                         return -1;
 148                                 }
 149                                 continue;
 150                         }
 151                         if (boot_record_count == 1)
 152                                 nftl->SpareMediaUnit = block;
 153
 154                         /* Mark this boot record (NFTL MediaHeader) block as reserved */
 155                         nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 156
 157
 158                         boot_record_count++;
 159                         continue;
 160                 }
 161
 162                 /* This is the first we've seen. Copy the media header structure into place */
 163                 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
 164
 165                 /* Do some sanity checks on it */
 166 #if 0
 167 The new DiskOnChip driver scans the MediaHeader itself, and presents a virtual
 168 erasesize based on UnitSizeFactor.  So the erasesize we read from the mtd
 169 device is already correct.
 170                 if (mh->UnitSizeFactor == 0) {
 171                         printk(KERN_NOTICE "NFTL: UnitSizeFactor 0x00 detected. This violates the spec but we think we know what it means...\n");
 172                 } else if (mh->UnitSizeFactor < 0xfc) {
 173                         printk(KERN_NOTICE "Sorry, we don't support UnitSizeFactor 0x%02x\n",
 174                                mh->UnitSizeFactor);
 175                         return -1;
 176                 } else if (mh->UnitSizeFactor != 0xff) {
 177                         printk(KERN_NOTICE "WARNING: Support for NFTL with UnitSizeFactor 0x%02x is experimental\n",
 178                                mh->UnitSizeFactor);
 179                         nftl->EraseSize = nftl->mbd.mtd->erasesize << (0xff - mh->UnitSizeFactor);
 180                         nftl->nb_blocks = nftl->mbd.mtd->size / nftl->EraseSize;
 181                 }
 182 #endif
 183                 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
 184                 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
 185                         printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
 186                         printk(KERN_NOTICE "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
 187                                nftl->nb_boot_blocks, nftl->nb_blocks);
 188                         return -1;
 189                 }
 190
 191                 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
 192                 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
 193                         printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
 194                         printk(KERN_NOTICE "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
 195                                nftl->numvunits, nftl->nb_blocks, nftl->nb_boot_blocks);
 196                         return -1;
 197                 }
 198
 199                 nftl->mbd.size  = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
 200
 201                 /* If we're not using the last sectors in the device for some reason,
 202                    reduce nb_blocks accordingly so we forget they're there */
 203                 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
 204
 205                 /* XXX: will be suppressed */
 206                 nftl->lastEUN = nftl->nb_blocks - 1;
 207
 208                 /* memory alloc */
 209                 nftl->EUNtable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
 210                 if (!nftl->EUNtable) {
 211                         printk(KERN_NOTICE "NFTL: allocation of EUNtable failed\n");
 212                         return -ENOMEM;
 213                 }
 214
 215                 nftl->ReplUnitTable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
 216                 if (!nftl->ReplUnitTable) {
 217                         kfree(nftl->EUNtable);
 218                         printk(KERN_NOTICE "NFTL: allocation of ReplUnitTable failed\n");
 219                         return -ENOMEM;
 220                 }
 221
 222                 /* mark the bios blocks (blocks before NFTL MediaHeader) as reserved */
 223                 for (i = 0; i < nftl->nb_boot_blocks; i++)
 224                         nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 225                 /* mark all remaining blocks as potentially containing data */
 226                 for (; i < nftl->nb_blocks; i++) {
 227                         nftl->ReplUnitTable[i] = BLOCK_NOTEXPLORED;
 228                 }
 229
 230                 /* Mark this boot record (NFTL MediaHeader) block as reserved */
 231                 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 232
 233                 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
 234                 for (i = 0; i < nftl->nb_blocks; i++) {
 235 #if 0
 236 The new DiskOnChip driver already scanned the bad block table.  Just query it.
 237                         if ((i & (SECTORSIZE - 1)) == 0) {
 238                                 /* read one sector for every SECTORSIZE of blocks */
 239                                 if ((ret = mtd->read(nftl->mbd.mtd, block * nftl->EraseSize +
 240                                                      i + SECTORSIZE, SECTORSIZE, &retlen,
 241                                                      buf)) < 0) {
 242                                         printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
 243                                                ret);
 244                                         kfree(nftl->ReplUnitTable);
 245                                         kfree(nftl->EUNtable);
 246                                         return -1;
 247                                 }
 248                         }
 249                         /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
 250                         if (buf[i & (SECTORSIZE - 1)] != 0xff)
 251                                 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 252 #endif
 253                         if (nftl->mbd.mtd->block_isbad(nftl->mbd.mtd, i * nftl->EraseSize))
 254                                 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
 255                 }
 256
 257                 nftl->MediaUnit = block;
 258                 boot_record_count++;
 259
 260         } /* foreach (block) */
 261
 262         return boot_record_count?0:-1;
 263 }
 264
 265 static int memcmpb(void *a, int c, int n)
 266 {
 267         int i;
 268         for (i = 0; i < n; i++) {
 269                 if (c != ((unsigned char *)a)[i])
 270                         return 1;
 271         }
 272         return 0;
 273 }
 274
 275 /* check_free_sector: check if a free sector is actually FREE, i.e. All 0xff in data and oob area */
 276 static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
 277                               int check_oob)
 278 {
 279         u8 buf[SECTORSIZE + nftl->mbd.mtd->oobsize];
 280         struct mtd_info *mtd = nftl->mbd.mtd;
 281         size_t retlen;
 282         int i;
 283
 284         for (i = 0; i < len; i += SECTORSIZE) {
 285                 if (mtd->read(mtd, address, SECTORSIZE, &retlen, buf))
 286                         return -1;
 287                 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
 288                         return -1;
 289
 290                 if (check_oob) {
 291                         if(nftl_read_oob(mtd, address, mtd->oobsize,
 292                                          &retlen, &buf[SECTORSIZE]) < 0)
 293                                 return -1;
 294                         if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
 295                                 return -1;
 296                 }
 297                 address += SECTORSIZE;
 298         }
 299
 300         return 0;
 301 }
 302
 303 /* NFTL_format: format a Erase Unit by erasing ALL Erase Zones in the Erase Unit and
 304  *              Update NFTL metadata. Each erase operation is checked with check_free_sectors
 305  *
 306  * Return: 0 when succeed, -1 on error.
 307  *
 308  *  ToDo: 1. Is it neceressary to check_free_sector after erasing ??
 309  */
 310 int NFTL_formatblock(struct NFTLrecord *nftl, int block)
 311 {
 312         size_t retlen;
 313         unsigned int nb_erases, erase_mark;
 314         struct nftl_uci1 uci;
 315         struct erase_info *instr = &nftl->instr;
 316         struct mtd_info *mtd = nftl->mbd.mtd;
 317
 318         /* Read the Unit Control Information #1 for Wear-Leveling */
 319         if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8,
 320                           8, &retlen, (char *)&uci) < 0)
 321                 goto default_uci1;
 322
 323         erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
 324         if (erase_mark != ERASE_MARK) {
 325         default_uci1:
 326                 uci.EraseMark = cpu_to_le16(ERASE_MARK);
 327                 uci.EraseMark1 = cpu_to_le16(ERASE_MARK);
 328                 uci.WearInfo = cpu_to_le32(0);
 329         }
 330
 331         memset(instr, 0, sizeof(struct erase_info));
 332
 333         /* XXX: use async erase interface, XXX: test return code */
 334         instr->mtd = nftl->mbd.mtd;
 335         instr->addr = block * nftl->EraseSize;
 336         instr->len = nftl->EraseSize;
 337         mtd->erase(mtd, instr);
 338
 339         if (instr->state == MTD_ERASE_FAILED) {
 340                 printk("Error while formatting block %d\n", block);
 341                 goto fail;
 342         }
 343
 344                 /* increase and write Wear-Leveling info */
 345                 nb_erases = le32_to_cpu(uci.WearInfo);
 346                 nb_erases++;
 347
 348                 /* wrap (almost impossible with current flashs) or free block */
 349                 if (nb_erases == 0)
 350                         nb_erases = 1;
 351
 352                 /* check the "freeness" of Erase Unit before updating metadata
 353                  * FixMe:  is this check really necessary ? since we have check the
 354                  *         return code after the erase operation. */
 355                 if (check_free_sectors(nftl, instr->addr, nftl->EraseSize, 1) != 0)
 356                         goto fail;
 357
 358                 uci.WearInfo = le32_to_cpu(nb_erases);
 359                 if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE +
 360                                    8, 8, &retlen, (char *)&uci) < 0)
 361                         goto fail;
 362                 return 0;
 363 fail:
 364         /* could not format, update the bad block table (caller is responsible
 365            for setting the ReplUnitTable to BLOCK_RESERVED on failure) */
 366         nftl->mbd.mtd->block_markbad(nftl->mbd.mtd, instr->addr);
 367         return -1;
 368 }
 369
 370 /* check_sectors_in_chain: Check that each sector of a Virtual Unit Chain is correct.
 371  *      Mark as 'IGNORE' each incorrect sector. This check is only done if the chain
 372  *      was being folded when NFTL was interrupted.
 373  *
 374  *      The check_free_sectors in this function is neceressary. There is a possible
 375  *      situation that after writing the Data area, the Block Control Information is
 376  *      not updated according (due to power failure or something) which leaves the block
 377  *      in an umconsistent state. So we have to check if a block is really FREE in this
 378  *      case. */
 379 static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
 380 {
 381         struct mtd_info *mtd = nftl->mbd.mtd;
 382         unsigned int block, i, status;
 383         struct nftl_bci bci;
 384         int sectors_per_block;
 385         size_t retlen;
 386
 387         sectors_per_block = nftl->EraseSize / SECTORSIZE;
 388         block = first_block;
 389         for (;;) {
 390                 for (i = 0; i < sectors_per_block; i++) {
 391                         if (nftl_read_oob(mtd,
 392                                           block * nftl->EraseSize + i * SECTORSIZE,
 393                                           8, &retlen, (char *)&bci) < 0)
 394                                 status = SECTOR_IGNORE;
 395                         else
 396                                 status = bci.Status | bci.Status1;
 397
 398                         switch(status) {
 399                         case SECTOR_FREE:
 400                                 /* verify that the sector is really free. If not, mark
 401                                    as ignore */
 402                                 if (memcmpb(&bci, 0xff, 8) != 0 ||
 403                                     check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE,
 404                                                        SECTORSIZE, 0) != 0) {
 405                                         printk("Incorrect free sector %d in block %d: "
 406                                                "marking it as ignored\n",
 407                                                i, block);
 408
 409                                         /* sector not free actually : mark it as SECTOR_IGNORE  */
 410                                         bci.Status = SECTOR_IGNORE;
 411                                         bci.Status1 = SECTOR_IGNORE;
 412                                         nftl_write_oob(mtd, block *
 413                                                        nftl->EraseSize +
 414                                                        i * SECTORSIZE, 8,
 415                                                        &retlen, (char *)&bci);
 416                                 }
 417                                 break;
 418                         default:
 419                                 break;
 420                         }
 421                 }
 422
 423                 /* proceed to next Erase Unit on the chain */
 424                 block = nftl->ReplUnitTable[block];
 425                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 426                         printk("incorrect ReplUnitTable[] : %d\n", block);
 427                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 428                         break;
 429         }
 430 }
 431
 432 /* calc_chain_lenght: Walk through a Virtual Unit Chain and estimate chain length */
 433 static int calc_chain_length(struct NFTLrecord *nftl, unsigned int first_block)
 434 {
 435         unsigned int length = 0, block = first_block;
 436
 437         for (;;) {
 438                 length++;
 439                 /* avoid infinite loops, although this is guaranted not to
 440                    happen because of the previous checks */
 441                 if (length >= nftl->nb_blocks) {
 442                         printk("nftl: length too long %d !\n", length);
 443                         break;
 444                 }
 445
 446                 block = nftl->ReplUnitTable[block];
 447                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 448                         printk("incorrect ReplUnitTable[] : %d\n", block);
 449                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 450                         break;
 451         }
 452         return length;
 453 }
 454
 455 /* format_chain: Format an invalid Virtual Unit chain. It frees all the Erase Units in a
 456  *      Virtual Unit Chain, i.e. all the units are disconnected.
 457  *
 458  *      It is not stricly correct to begin from the first block of the chain because
 459  *      if we stop the code, we may see again a valid chain if there was a first_block
 460  *      flag in a block inside it. But is it really a problem ?
 461  *
 462  * FixMe: Figure out what the last statesment means. What if power failure when we are
 463  *      in the for (;;) loop formatting blocks ??
 464  */
 465 static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
 466 {
 467         unsigned int block = first_block, block1;
 468
 469         printk("Formatting chain at block %d\n", first_block);
 470
 471         for (;;) {
 472                 block1 = nftl->ReplUnitTable[block];
 473
 474                 printk("Formatting block %d\n", block);
 475                 if (NFTL_formatblock(nftl, block) < 0) {
 476                         /* cannot format !!!! Mark it as Bad Unit */
 477                         nftl->ReplUnitTable[block] = BLOCK_RESERVED;
 478                 } else {
 479                         nftl->ReplUnitTable[block] = BLOCK_FREE;
 480                 }
 481
 482                 /* goto next block on the chain */
 483                 block = block1;
 484
 485                 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
 486                         printk("incorrect ReplUnitTable[] : %d\n", block);
 487                 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
 488                         break;
 489         }
 490 }
 491
 492 /* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or
 493  *      totally free (only 0xff).
 494  *
 495  * Definition: Free Erase Unit -- A properly erased/formatted Free Erase Unit should have meet the
 496  *      following critia:
 497  *      1. */
 498 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
 499 {
 500         struct mtd_info *mtd = nftl->mbd.mtd;
 501         struct nftl_uci1 h1;
 502         unsigned int erase_mark;
 503         size_t retlen;
 504
 505         /* check erase mark. */
 506         if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
 507                           &retlen, (char *)&h1) < 0)
 508                 return -1;
 509
 510         erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
 511         if (erase_mark != ERASE_MARK) {
 512                 /* if no erase mark, the block must be totally free. This is
 513                    possible in two cases : empty filsystem or interrupted erase (very unlikely) */
 514                 if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0)
 515                         return -1;
 516
 517                 /* free block : write erase mark */
 518                 h1.EraseMark = cpu_to_le16(ERASE_MARK);
 519                 h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
 520                 h1.WearInfo = cpu_to_le32(0);
 521                 if (nftl_write_oob(mtd,
 522                                    block * nftl->EraseSize + SECTORSIZE + 8, 8,
 523                                    &retlen, (char *)&h1) < 0)
 524                         return -1;
 525         } else {
 526 #if 0
 527                 /* if erase mark present, need to skip it when doing check */
 528                 for (i = 0; i < nftl->EraseSize; i += SECTORSIZE) {
 529                         /* check free sector */
 530                         if (check_free_sectors (nftl, block * nftl->EraseSize + i,
 531                                                 SECTORSIZE, 0) != 0)
 532                                 return -1;
 533
 534                         if (nftl_read_oob(mtd, block * nftl->EraseSize + i,
 535                                           16, &retlen, buf) < 0)
 536                                 return -1;
 537                         if (i == SECTORSIZE) {
 538                                 /* skip erase mark */
 539                                 if (memcmpb(buf, 0xff, 8))
 540                                         return -1;
 541                         } else {
 542                                 if (memcmpb(buf, 0xff, 16))
 543                                         return -1;
 544                         }
 545                 }
 546 #endif
 547         }
 548
 549         return 0;
 550 }
 551
 552 /* get_fold_mark: Read fold mark from Unit Control Information #2, we use FOLD_MARK_IN_PROGRESS
 553  *      to indicate that we are in the progression of a Virtual Unit Chain folding. If the UCI #2
 554  *      is FOLD_MARK_IN_PROGRESS when mounting the NFTL, the (previous) folding process is interrupted
 555  *      for some reason. A clean up/check of the VUC is neceressary in this case.
 556  *
 557  * WARNING: return 0 if read error
 558  */
 559 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
 560 {
 561         struct mtd_info *mtd = nftl->mbd.mtd;
 562         struct nftl_uci2 uci;
 563         size_t retlen;
 564
 565         if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
 566                           8, &retlen, (char *)&uci) < 0)
 567                 return 0;
 568
 569         return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
 570 }
 571
 572 int NFTL_mount(struct NFTLrecord *s)
 573 {
 574         int i;
 575         unsigned int first_logical_block, logical_block, rep_block, nb_erases, erase_mark;
 576         unsigned int block, first_block, is_first_block;
 577         int chain_length, do_format_chain;
 578         struct nftl_uci0 h0;
 579         struct nftl_uci1 h1;
 580         struct mtd_info *mtd = s->mbd.mtd;
 581         size_t retlen;
 582
 583         /* search for NFTL MediaHeader and Spare NFTL Media Header */
 584         if (find_boot_record(s) < 0) {
 585                 printk("Could not find valid boot record\n");
 586                 return -1;
 587         }
 588
 589         /* init the logical to physical table */
 590         for (i = 0; i < s->nb_blocks; i++) {
 591                 s->EUNtable[i] = BLOCK_NIL;
 592         }
 593
 594         /* first pass : explore each block chain */
 595         first_logical_block = 0;
 596         for (first_block = 0; first_block < s->nb_blocks; first_block++) {
 597                 /* if the block was not already explored, we can look at it */
 598                 if (s->ReplUnitTable[first_block] == BLOCK_NOTEXPLORED) {
 599                         block = first_block;
 600                         chain_length = 0;
 601                         do_format_chain = 0;
 602
 603                         for (;;) {
 604                                 /* read the block header. If error, we format the chain */
 605                                 if (nftl_read_oob(mtd,
 606                                                   block * s->EraseSize + 8, 8,
 607                                                   &retlen, (char *)&h0) < 0 ||
 608                                     nftl_read_oob(mtd,
 609                                                   block * s->EraseSize +
 610                                                   SECTORSIZE + 8, 8,
 611                                                   &retlen, (char *)&h1) < 0) {
 612                                         s->ReplUnitTable[block] = BLOCK_NIL;
 613                                         do_format_chain = 1;
 614                                         break;
 615                                 }
 616
 617                                 logical_block = le16_to_cpu ((h0.VirtUnitNum | h0.SpareVirtUnitNum));
 618                                 rep_block = le16_to_cpu ((h0.ReplUnitNum | h0.SpareReplUnitNum));
 619                                 nb_erases = le32_to_cpu (h1.WearInfo);
 620                                 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
 621
 622                                 is_first_block = !(logical_block >> 15);
 623                                 logical_block = logical_block & 0x7fff;
 624
 625                                 /* invalid/free block test */
 626                                 if (erase_mark != ERASE_MARK || logical_block >= s->nb_blocks) {
 627                                         if (chain_length == 0) {
 628                                                 /* if not currently in a chain, we can handle it safely */
 629                                                 if (check_and_mark_free_block(s, block) < 0) {
 630                                                         /* not really free: format it */
 631                                                         printk("Formatting block %d\n", block);
 632                                                         if (NFTL_formatblock(s, block) < 0) {
 633                                                                 /* could not format: reserve the block */
 634                                                                 s->ReplUnitTable[block] = BLOCK_RESERVED;
 635                                                         } else {
 636                                                                 s->ReplUnitTable[block] = BLOCK_FREE;
 637                                                         }
 638                                                 } else {
 639                                                         /* free block: mark it */
 640                                                         s->ReplUnitTable[block] = BLOCK_FREE;
 641                                                 }
 642                                                 /* directly examine the next block. */
 643                                                 goto examine_ReplUnitTable;
 644                                         } else {
 645                                                 /* the block was in a chain : this is bad. We
 646                                                    must format all the chain */
 647                                                 printk("Block %d: free but referenced in chain %d\n",
 648                                                        block, first_block);
 649                                                 s->ReplUnitTable[block] = BLOCK_NIL;
 650                                                 do_format_chain = 1;
 651                                                 break;
 652                                         }
 653                                 }
 654
 655                                 /* we accept only first blocks here */
 656                                 if (chain_length == 0) {
 657                                         /* this block is not the first block in chain :
 658                                            ignore it, it will be included in a chain
 659                                            later, or marked as not explored */
 660                                         if (!is_first_block)
 661                                                 goto examine_ReplUnitTable;
 662                                         first_logical_block = logical_block;
 663                                 } else {
 664                                         if (logical_block != first_logical_block) {
 665                                                 printk("Block %d: incorrect logical block: %d expected: %d\n",
 666                                                        block, logical_block, first_logical_block);
 667                                                 /* the chain is incorrect : we must format it,
 668                                                    but we need to read it completly */
 669                                                 do_format_chain = 1;
 670                                         }
 671                                         if (is_first_block) {
 672                                                 /* we accept that a block is marked as first
 673                                                    block while being last block in a chain
 674                                                    only if the chain is being folded */
 675                                                 if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS ||
 676                                                     rep_block != 0xffff) {
 677                                                         printk("Block %d: incorrectly marked as first block in chain\n",
 678                                                                block);
 679                                                         /* the chain is incorrect : we must format it,
 680                                                            but we need to read it completly */
 681                                                         do_format_chain = 1;
 682                                                 } else {
 683                                                         printk("Block %d: folding in progress - ignoring first block flag\n",
 684                                                                block);
 685                                                 }
 686                                         }
 687                                 }
 688                                 chain_length++;
 689                                 if (rep_block == 0xffff) {
 690                                         /* no more blocks after */
 691                                         s->ReplUnitTable[block] = BLOCK_NIL;
 692                                         break;
 693                                 } else if (rep_block >= s->nb_blocks) {
 694                                         printk("Block %d: referencing invalid block %d\n",
 695                                                block, rep_block);
 696                                         do_format_chain = 1;
 697                                         s->ReplUnitTable[block] = BLOCK_NIL;
 698                                         break;
 699                                 } else if (s->ReplUnitTable[rep_block] != BLOCK_NOTEXPLORED) {
 700                                         /* same problem as previous 'is_first_block' test:
 701                                            we accept that the last block of a chain has
 702                                            the first_block flag set if folding is in
 703                                            progress. We handle here the case where the
 704                                            last block appeared first */
 705                                         if (s->ReplUnitTable[rep_block] == BLOCK_NIL &&
 706                                             s->EUNtable[first_logical_block] == rep_block &&
 707                                             get_fold_mark(s, first_block) == FOLD_MARK_IN_PROGRESS) {
 708                                                 /* EUNtable[] will be set after */
 709                                                 printk("Block %d: folding in progress - ignoring first block flag\n",
 710                                                        rep_block);
 711                                                 s->ReplUnitTable[block] = rep_block;
 712                                                 s->EUNtable[first_logical_block] = BLOCK_NIL;
 713                                         } else {
 714                                                 printk("Block %d: referencing block %d already in another chain\n",
 715                                                        block, rep_block);
 716                                                 /* XXX: should handle correctly fold in progress chains */
 717                                                 do_format_chain = 1;
 718                                                 s->ReplUnitTable[block] = BLOCK_NIL;
 719                                         }
 720                                         break;
 721                                 } else {
 722                                         /* this is OK */
 723                                         s->ReplUnitTable[block] = rep_block;
 724                                         block = rep_block;
 725                                 }
 726                         }
 727
 728                         /* the chain was completely explored. Now we can decide
 729                            what to do with it */
 730                         if (do_format_chain) {
 731                                 /* invalid chain : format it */
 732                                 format_chain(s, first_block);
 733                         } else {
 734                                 unsigned int first_block1, chain_to_format, chain_length1;
 735                                 int fold_mark;
 736
 737                                 /* valid chain : get foldmark */
 738                                 fold_mark = get_fold_mark(s, first_block);
 739                                 if (fold_mark == 0) {
 740                                         /* cannot get foldmark : format the chain */
 741                                         printk("Could read foldmark at block %d\n", first_block);
 742                                         format_chain(s, first_block);
 743                                 } else {
 744                                         if (fold_mark == FOLD_MARK_IN_PROGRESS)
 745                                                 check_sectors_in_chain(s, first_block);
 746
 747                                         /* now handle the case where we find two chains at the
 748                                            same virtual address : we select the longer one,
 749                                            because the shorter one is the one which was being
 750                                            folded if the folding was not done in place */
 751                                         first_block1 = s->EUNtable[first_logical_block];
 752                                         if (first_block1 != BLOCK_NIL) {
 753                                                 /* XXX: what to do if same length ? */
 754                                                 chain_length1 = calc_chain_length(s, first_block1);
 755                                                 printk("Two chains at blocks %d (len=%d) and %d (len=%d)\n",
 756                                                        first_block1, chain_length1, first_block, chain_length);
 757
 758                                                 if (chain_length >= chain_length1) {
 759                                                         chain_to_format = first_block1;
 760                                                         s->EUNtable[first_logical_block] = first_block;
 761                                                 } else {
 762                                                         chain_to_format = first_block;
 763                                                 }
 764                                                 format_chain(s, chain_to_format);
 765                                         } else {
 766                                                 s->EUNtable[first_logical_block] = first_block;
 767                                         }
 768                                 }
 769                         }
 770                 }
 771         examine_ReplUnitTable:;
 772         }
 773
 774         /* second pass to format unreferenced blocks  and init free block count */
 775         s->numfreeEUNs = 0;
 776         s->LastFreeEUN = le16_to_cpu(s->MediaHdr.FirstPhysicalEUN);
 777
 778         for (block = 0; block < s->nb_blocks; block++) {
 779                 if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) {
 780                         printk("Unreferenced block %d, formatting it\n", block);
 781                         if (NFTL_formatblock(s, block) < 0)
 782                                 s->ReplUnitTable[block] = BLOCK_RESERVED;
 783                         else
 784                                 s->ReplUnitTable[block] = BLOCK_FREE;
 785                 }
 786                 if (s->ReplUnitTable[block] == BLOCK_FREE) {
 787                         s->numfreeEUNs++;
 788                         s->LastFreeEUN = block;
 789                 }
 790         }
 791
 792         return 0;
 793 }