[PATCH 2/2] mtd: remove nftl support
Artem Bityutskiy
dedekind1 at gmail.com
Wed Mar 6 03:54:59 EST 2013
From: Artem Bityutskiy <artem.bityutskiy at linux.intel.com>
This is very old cruft with all the users probably dead. Newer DoC devices use
inftl.
Signed-off-by: Artem Bityutskiy <artem.bityutskiy at linux.intel.com>
---
drivers/mtd/Kconfig | 30 --
drivers/mtd/Makefile | 2 -
drivers/mtd/nftlcore.c | 829 -----------------------------------------------
drivers/mtd/nftlmount.c | 786 --------------------------------------------
4 files changed, 1647 deletions(-)
delete mode 100644 drivers/mtd/nftlcore.c
delete mode 100644 drivers/mtd/nftlmount.c
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 557bec5..eaf2a44 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -195,9 +195,6 @@ config MTD_BLOCK
this is very unsafe, but could be useful for file systems which are
almost never written to.
- You do not need this option for use with the DiskOnChip devices. For
- those, enable NFTL support (CONFIG_NFTL) instead.
-
config MTD_BLOCK_RO
tristate "Readonly block device access to MTD devices"
depends on MTD_BLOCK!=y && BLOCK
@@ -207,9 +204,6 @@ config MTD_BLOCK_RO
from an MTD device, without the overhead (and danger) of the caching
driver.
- You do not need this option for use with the DiskOnChip devices. For
- those, enable NFTL support (CONFIG_NFTL) instead.
-
config FTL
tristate "FTL (Flash Translation Layer) support"
depends on BLOCK
@@ -227,30 +221,6 @@ config FTL
permitted to copy, modify and distribute the code as you wish. Just
not use it.
-config NFTL
- tristate "NFTL (NAND Flash Translation Layer) support"
- depends on BLOCK
- select MTD_BLKDEVS
- ---help---
- This provides support for the NAND Flash Translation Layer which is
- used on M-Systems' DiskOnChip devices. It uses a kind of pseudo-
- file system on a flash device to emulate a block device with
- 512-byte sectors, on top of which you put a 'normal' file system.
-
- You may find that the algorithms used in this code are patented
- unless you live in the Free World where software patents aren't
- legal - in the USA you are only permitted to use this on DiskOnChip
- hardware, although under the terms of the GPL you're obviously
- permitted to copy, modify and distribute the code as you wish. Just
- not use it.
-
-config NFTL_RW
- bool "Write support for NFTL"
- depends on NFTL
- help
- Support for writing to the NAND Flash Translation Layer, as used
- on the DiskOnChip.
-
config INFTL
tristate "INFTL (Inverse NAND Flash Translation Layer) support"
depends on BLOCK
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index 18a38e5..39f616a 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -20,7 +20,6 @@ obj-$(CONFIG_MTD_BLKDEVS) += mtd_blkdevs.o
obj-$(CONFIG_MTD_BLOCK) += mtdblock.o
obj-$(CONFIG_MTD_BLOCK_RO) += mtdblock_ro.o
obj-$(CONFIG_FTL) += ftl.o
-obj-$(CONFIG_NFTL) += nftl.o
obj-$(CONFIG_INFTL) += inftl.o
obj-$(CONFIG_RFD_FTL) += rfd_ftl.o
obj-$(CONFIG_SSFDC) += ssfdc.o
@@ -28,7 +27,6 @@ obj-$(CONFIG_SM_FTL) += sm_ftl.o
obj-$(CONFIG_MTD_OOPS) += mtdoops.o
obj-$(CONFIG_MTD_SWAP) += mtdswap.o
-nftl-objs := nftlcore.o nftlmount.o
inftl-objs := inftlcore.o inftlmount.o
obj-y += chips/ lpddr/ maps/ devices/ nand/ onenand/ tests/
diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
deleted file mode 100644
index c5f4ebf..0000000
--- a/drivers/mtd/nftlcore.c
+++ /dev/null
@@ -1,829 +0,0 @@
-/*
- * Linux driver for NAND Flash Translation Layer
- *
- * Copyright © 1999 Machine Vision Holdings, Inc.
- * Copyright © 1999-2010 David Woodhouse <dwmw2 at infradead.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#define PRERELEASE
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <asm/errno.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/hdreg.h>
-#include <linux/blkdev.h>
-
-#include <linux/kmod.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/nand.h>
-#include <linux/mtd/nftl.h>
-#include <linux/mtd/blktrans.h>
-
-/* maximum number of loops while examining next block, to have a
- chance to detect consistency problems (they should never happen
- because of the checks done in the mounting */
-
-#define MAX_LOOPS 10000
-
-
-static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
-{
- struct NFTLrecord *nftl;
- unsigned long temp;
-
- if (mtd->type != MTD_NANDFLASH || mtd->size > UINT_MAX)
- return;
- /* OK, this is moderately ugly. But probably safe. Alternatives? */
- if (memcmp(mtd->name, "DiskOnChip", 10))
- return;
-
- pr_debug("NFTL: add_mtd for %s\n", mtd->name);
-
- nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
-
- if (!nftl)
- return;
-
- nftl->mbd.mtd = mtd;
- nftl->mbd.devnum = -1;
-
- nftl->mbd.tr = tr;
-
- if (NFTL_mount(nftl) < 0) {
- printk(KERN_WARNING "NFTL: could not mount device\n");
- kfree(nftl);
- return;
- }
-
- /* OK, it's a new one. Set up all the data structures. */
-
- /* Calculate geometry */
- nftl->cylinders = 1024;
- nftl->heads = 16;
-
- temp = nftl->cylinders * nftl->heads;
- nftl->sectors = nftl->mbd.size / temp;
- if (nftl->mbd.size % temp) {
- nftl->sectors++;
- temp = nftl->cylinders * nftl->sectors;
- nftl->heads = nftl->mbd.size / temp;
-
- if (nftl->mbd.size % temp) {
- nftl->heads++;
- temp = nftl->heads * nftl->sectors;
- nftl->cylinders = nftl->mbd.size / temp;
- }
- }
-
- if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) {
- /*
- Oh no we don't have
- mbd.size == heads * cylinders * sectors
- */
- printk(KERN_WARNING "NFTL: cannot calculate a geometry to "
- "match size of 0x%lx.\n", nftl->mbd.size);
- printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d "
- "(== 0x%lx sects)\n",
- nftl->cylinders, nftl->heads , nftl->sectors,
- (long)nftl->cylinders * (long)nftl->heads *
- (long)nftl->sectors );
- }
-
- if (add_mtd_blktrans_dev(&nftl->mbd)) {
- kfree(nftl->ReplUnitTable);
- kfree(nftl->EUNtable);
- kfree(nftl);
- return;
- }
-#ifdef PSYCHO_DEBUG
- printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a');
-#endif
-}
-
-static void nftl_remove_dev(struct mtd_blktrans_dev *dev)
-{
- struct NFTLrecord *nftl = (void *)dev;
-
- pr_debug("NFTL: remove_dev (i=%d)\n", dev->devnum);
-
- del_mtd_blktrans_dev(dev);
- kfree(nftl->ReplUnitTable);
- kfree(nftl->EUNtable);
-}
-
-/*
- * Read oob data from flash
- */
-int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
- size_t *retlen, uint8_t *buf)
-{
- loff_t mask = mtd->writesize - 1;
- struct mtd_oob_ops ops;
- int res;
-
- ops.mode = MTD_OPS_PLACE_OOB;
- ops.ooboffs = offs & mask;
- ops.ooblen = len;
- ops.oobbuf = buf;
- ops.datbuf = NULL;
-
- res = mtd_read_oob(mtd, offs & ~mask, &ops);
- *retlen = ops.oobretlen;
- return res;
-}
-
-/*
- * Write oob data to flash
- */
-int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
- size_t *retlen, uint8_t *buf)
-{
- loff_t mask = mtd->writesize - 1;
- struct mtd_oob_ops ops;
- int res;
-
- ops.mode = MTD_OPS_PLACE_OOB;
- ops.ooboffs = offs & mask;
- ops.ooblen = len;
- ops.oobbuf = buf;
- ops.datbuf = NULL;
-
- res = mtd_write_oob(mtd, offs & ~mask, &ops);
- *retlen = ops.oobretlen;
- return res;
-}
-
-#ifdef CONFIG_NFTL_RW
-
-/*
- * Write data and oob to flash
- */
-static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
- size_t *retlen, uint8_t *buf, uint8_t *oob)
-{
- loff_t mask = mtd->writesize - 1;
- struct mtd_oob_ops ops;
- int res;
-
- ops.mode = MTD_OPS_PLACE_OOB;
- ops.ooboffs = offs & mask;
- ops.ooblen = mtd->oobsize;
- ops.oobbuf = oob;
- ops.datbuf = buf;
- ops.len = len;
-
- res = mtd_write_oob(mtd, offs & ~mask, &ops);
- *retlen = ops.retlen;
- return res;
-}
-
-/* Actual NFTL access routines */
-/* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
- * when the give Virtual Unit Chain
- */
-static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
-{
- /* For a given Virtual Unit Chain: find or create a free block and
- add it to the chain */
- /* We're passed the number of the last EUN in the chain, to save us from
- having to look it up again */
- u16 pot = nftl->LastFreeEUN;
- int silly = nftl->nb_blocks;
-
- /* Normally, we force a fold to happen before we run out of free blocks completely */
- if (!desperate && nftl->numfreeEUNs < 2) {
- pr_debug("NFTL_findfreeblock: there are too few free EUNs\n");
- return BLOCK_NIL;
- }
-
- /* Scan for a free block */
- do {
- if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
- nftl->LastFreeEUN = pot;
- nftl->numfreeEUNs--;
- return pot;
- }
-
- /* This will probably point to the MediaHdr unit itself,
- right at the beginning of the partition. But that unit
- (and the backup unit too) should have the UCI set
- up so that it's not selected for overwriting */
- if (++pot > nftl->lastEUN)
- pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
-
- if (!silly--) {
- printk("Argh! No free blocks found! LastFreeEUN = %d, "
- "FirstEUN = %d\n", nftl->LastFreeEUN,
- le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
- return BLOCK_NIL;
- }
- } while (pot != nftl->LastFreeEUN);
-
- return BLOCK_NIL;
-}
-
-static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
-{
- struct mtd_info *mtd = nftl->mbd.mtd;
- u16 BlockMap[MAX_SECTORS_PER_UNIT];
- unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
- unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
- unsigned int thisEUN;
- int block;
- int silly;
- unsigned int targetEUN;
- struct nftl_oob oob;
- int inplace = 1;
- size_t retlen;
-
- memset(BlockMap, 0xff, sizeof(BlockMap));
- memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
-
- thisEUN = nftl->EUNtable[thisVUC];
-
- if (thisEUN == BLOCK_NIL) {
- printk(KERN_WARNING "Trying to fold non-existent "
- "Virtual Unit Chain %d!\n", thisVUC);
- return BLOCK_NIL;
- }
-
- /* Scan to find the Erase Unit which holds the actual data for each
- 512-byte block within the Chain.
- */
- silly = MAX_LOOPS;
- targetEUN = BLOCK_NIL;
- while (thisEUN <= nftl->lastEUN ) {
- unsigned int status, foldmark;
-
- targetEUN = thisEUN;
- for (block = 0; block < nftl->EraseSize / 512; block ++) {
- nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
- (block * 512), 16 , &retlen,
- (char *)&oob);
- if (block == 2) {
- foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
- if (foldmark == FOLD_MARK_IN_PROGRESS) {
- pr_debug("Write Inhibited on EUN %d\n", thisEUN);
- inplace = 0;
- } else {
- /* There's no other reason not to do inplace,
- except ones that come later. So we don't need
- to preserve inplace */
- inplace = 1;
- }
- }
- status = oob.b.Status | oob.b.Status1;
- BlockLastState[block] = status;
-
- switch(status) {
- case SECTOR_FREE:
- BlockFreeFound[block] = 1;
- break;
-
- case SECTOR_USED:
- if (!BlockFreeFound[block])
- BlockMap[block] = thisEUN;
- else
- printk(KERN_WARNING
- "SECTOR_USED found after SECTOR_FREE "
- "in Virtual Unit Chain %d for block %d\n",
- thisVUC, block);
- break;
- case SECTOR_DELETED:
- if (!BlockFreeFound[block])
- BlockMap[block] = BLOCK_NIL;
- else
- printk(KERN_WARNING
- "SECTOR_DELETED found after SECTOR_FREE "
- "in Virtual Unit Chain %d for block %d\n",
- thisVUC, block);
- break;
-
- case SECTOR_IGNORE:
- break;
- default:
- printk("Unknown status for block %d in EUN %d: %x\n",
- block, thisEUN, status);
- }
- }
-
- if (!silly--) {
- printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n",
- thisVUC);
- return BLOCK_NIL;
- }
-
- thisEUN = nftl->ReplUnitTable[thisEUN];
- }
-
- if (inplace) {
- /* We're being asked to be a fold-in-place. Check
- that all blocks which actually have data associated
- with them (i.e. BlockMap[block] != BLOCK_NIL) are
- either already present or SECTOR_FREE in the target
- block. If not, we're going to have to fold out-of-place
- anyway.
- */
- for (block = 0; block < nftl->EraseSize / 512 ; block++) {
- if (BlockLastState[block] != SECTOR_FREE &&
- BlockMap[block] != BLOCK_NIL &&
- BlockMap[block] != targetEUN) {
- pr_debug("Setting inplace to 0. VUC %d, "
- "block %d was %x lastEUN, "
- "and is in EUN %d (%s) %d\n",
- thisVUC, block, BlockLastState[block],
- BlockMap[block],
- BlockMap[block]== targetEUN ? "==" : "!=",
- targetEUN);
- inplace = 0;
- break;
- }
- }
-
- if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
- pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
- BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
- SECTOR_FREE) {
- pr_debug("Pending write not free in EUN %d. "
- "Folding out of place.\n", targetEUN);
- inplace = 0;
- }
- }
-
- if (!inplace) {
- pr_debug("Cannot fold Virtual Unit Chain %d in place. "
- "Trying out-of-place\n", thisVUC);
- /* We need to find a targetEUN to fold into. */
- targetEUN = NFTL_findfreeblock(nftl, 1);
- if (targetEUN == BLOCK_NIL) {
- /* Ouch. Now we're screwed. We need to do a
- fold-in-place of another chain to make room
- for this one. We need a better way of selecting
- which chain to fold, because makefreeblock will
- only ask us to fold the same one again.
- */
- printk(KERN_WARNING
- "NFTL_findfreeblock(desperate) returns 0xffff.\n");
- return BLOCK_NIL;
- }
- } else {
- /* We put a fold mark in the chain we are folding only if we
- fold in place to help the mount check code. If we do not fold in
- place, it is possible to find the valid chain by selecting the
- longer one */
- oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
- oob.u.c.unused = 0xffffffff;
- nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8,
- 8, &retlen, (char *)&oob.u);
- }
-
- /* OK. We now know the location of every block in the Virtual Unit Chain,
- and the Erase Unit into which we are supposed to be copying.
- Go for it.
- */
- pr_debug("Folding chain %d into unit %d\n", thisVUC, targetEUN);
- for (block = 0; block < nftl->EraseSize / 512 ; block++) {
- unsigned char movebuf[512];
- int ret;
-
- /* If it's in the target EUN already, or if it's pending write, do nothing */
- if (BlockMap[block] == targetEUN ||
- (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
- continue;
- }
-
- /* copy only in non free block (free blocks can only
- happen in case of media errors or deleted blocks) */
- if (BlockMap[block] == BLOCK_NIL)
- continue;
-
- ret = mtd_read(mtd,
- (nftl->EraseSize * BlockMap[block]) + (block * 512),
- 512,
- &retlen,
- movebuf);
- if (ret < 0 && !mtd_is_bitflip(ret)) {
- ret = mtd_read(mtd,
- (nftl->EraseSize * BlockMap[block]) + (block * 512),
- 512,
- &retlen,
- movebuf);
- if (ret != -EIO)
- printk("Error went away on retry.\n");
- }
- memset(&oob, 0xff, sizeof(struct nftl_oob));
- oob.b.Status = oob.b.Status1 = SECTOR_USED;
-
- nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) +
- (block * 512), 512, &retlen, movebuf, (char *)&oob);
- }
-
- /* add the header so that it is now a valid chain */
- oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
- oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = BLOCK_NIL;
-
- nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8,
- 8, &retlen, (char *)&oob.u);
-
- /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
-
- /* At this point, we have two different chains for this Virtual Unit, and no way to tell
- them apart. If we crash now, we get confused. However, both contain the same data, so we
- shouldn't actually lose data in this case. It's just that when we load up on a medium which
- has duplicate chains, we need to free one of the chains because it's not necessary any more.
- */
- thisEUN = nftl->EUNtable[thisVUC];
- pr_debug("Want to erase\n");
-
- /* For each block in the old chain (except the targetEUN of course),
- free it and make it available for future use */
- while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
- unsigned int EUNtmp;
-
- EUNtmp = nftl->ReplUnitTable[thisEUN];
-
- if (NFTL_formatblock(nftl, thisEUN) < 0) {
- /* could not erase : mark block as reserved
- */
- nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
- } else {
- /* correctly erased : mark it as free */
- nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
- nftl->numfreeEUNs++;
- }
- thisEUN = EUNtmp;
- }
-
- /* Make this the new start of chain for thisVUC */
- nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
- nftl->EUNtable[thisVUC] = targetEUN;
-
- return targetEUN;
-}
-
-static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
-{
- /* This is the part that needs some cleverness applied.
- For now, I'm doing the minimum applicable to actually
- get the thing to work.
- Wear-levelling and other clever stuff needs to be implemented
- and we also need to do some assessment of the results when
- the system loses power half-way through the routine.
- */
- u16 LongestChain = 0;
- u16 ChainLength = 0, thislen;
- u16 chain, EUN;
-
- for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
- EUN = nftl->EUNtable[chain];
- thislen = 0;
-
- while (EUN <= nftl->lastEUN) {
- thislen++;
- //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN);
- EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
- if (thislen > 0xff00) {
- printk("Endless loop in Virtual Chain %d: Unit %x\n",
- chain, EUN);
- }
- if (thislen > 0xff10) {
- /* Actually, don't return failure. Just ignore this chain and
- get on with it. */
- thislen = 0;
- break;
- }
- }
-
- if (thislen > ChainLength) {
- //printk("New longest chain is %d with length %d\n", chain, thislen);
- ChainLength = thislen;
- LongestChain = chain;
- }
- }
-
- if (ChainLength < 2) {
- printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
- "Failing request\n");
- return BLOCK_NIL;
- }
-
- return NFTL_foldchain (nftl, LongestChain, pendingblock);
-}
-
-/* NFTL_findwriteunit: Return the unit number into which we can write
- for this block. Make it available if it isn't already
-*/
-static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
-{
- u16 lastEUN;
- u16 thisVUC = block / (nftl->EraseSize / 512);
- struct mtd_info *mtd = nftl->mbd.mtd;
- unsigned int writeEUN;
- unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
- size_t retlen;
- int silly, silly2 = 3;
- struct nftl_oob oob;
-
- do {
- /* Scan the media to find a unit in the VUC which has
- a free space for the block in question.
- */
-
- /* This condition catches the 0x[7f]fff cases, as well as
- being a sanity check for past-end-of-media access
- */
- lastEUN = BLOCK_NIL;
- writeEUN = nftl->EUNtable[thisVUC];
- silly = MAX_LOOPS;
- while (writeEUN <= nftl->lastEUN) {
- struct nftl_bci bci;
- size_t retlen;
- unsigned int status;
-
- lastEUN = writeEUN;
-
- nftl_read_oob(mtd,
- (writeEUN * nftl->EraseSize) + blockofs,
- 8, &retlen, (char *)&bci);
-
- pr_debug("Status of block %d in EUN %d is %x\n",
- block , writeEUN, le16_to_cpu(bci.Status));
-
- status = bci.Status | bci.Status1;
- switch(status) {
- case SECTOR_FREE:
- return writeEUN;
-
- case SECTOR_DELETED:
- case SECTOR_USED:
- case SECTOR_IGNORE:
- break;
- default:
- // Invalid block. Don't use it any more. Must implement.
- break;
- }
-
- if (!silly--) {
- printk(KERN_WARNING
- "Infinite loop in Virtual Unit Chain 0x%x\n",
- thisVUC);
- return BLOCK_NIL;
- }
-
- /* Skip to next block in chain */
- writeEUN = nftl->ReplUnitTable[writeEUN];
- }
-
- /* OK. We didn't find one in the existing chain, or there
- is no existing chain. */
-
- /* Try to find an already-free block */
- writeEUN = NFTL_findfreeblock(nftl, 0);
-
- if (writeEUN == BLOCK_NIL) {
- /* That didn't work - there were no free blocks just
- waiting to be picked up. We're going to have to fold
- a chain to make room.
- */
-
- /* First remember the start of this chain */
- //u16 startEUN = nftl->EUNtable[thisVUC];
-
- //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC);
- writeEUN = NFTL_makefreeblock(nftl, BLOCK_NIL);
-
- if (writeEUN == BLOCK_NIL) {
- /* OK, we accept that the above comment is
- lying - there may have been free blocks
- last time we called NFTL_findfreeblock(),
- but they are reserved for when we're
- desperate. Well, now we're desperate.
- */
- pr_debug("Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC);
- writeEUN = NFTL_findfreeblock(nftl, 1);
- }
- if (writeEUN == BLOCK_NIL) {
- /* Ouch. This should never happen - we should
- always be able to make some room somehow.
- If we get here, we've allocated more storage
- space than actual media, or our makefreeblock
- routine is missing something.
- */
- printk(KERN_WARNING "Cannot make free space.\n");
- return BLOCK_NIL;
- }
- //printk("Restarting scan\n");
- lastEUN = BLOCK_NIL;
- continue;
- }
-
- /* We've found a free block. Insert it into the chain. */
-
- if (lastEUN != BLOCK_NIL) {
- thisVUC |= 0x8000; /* It's a replacement block */
- } else {
- /* The first block in a new chain */
- nftl->EUNtable[thisVUC] = writeEUN;
- }
-
- /* set up the actual EUN we're writing into */
- /* Both in our cache... */
- nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
-
- /* ... and on the flash itself */
- nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
- &retlen, (char *)&oob.u);
-
- oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
-
- nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8,
- &retlen, (char *)&oob.u);
-
- /* we link the new block to the chain only after the
- block is ready. It avoids the case where the chain
- could point to a free block */
- if (lastEUN != BLOCK_NIL) {
- /* Both in our cache... */
- nftl->ReplUnitTable[lastEUN] = writeEUN;
- /* ... and on the flash itself */
- nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
- 8, &retlen, (char *)&oob.u);
-
- oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
- = cpu_to_le16(writeEUN);
-
- nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8,
- 8, &retlen, (char *)&oob.u);
- }
-
- return writeEUN;
-
- } while (silly2--);
-
- printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n",
- thisVUC);
- return BLOCK_NIL;
-}
-
-static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
- char *buffer)
-{
- struct NFTLrecord *nftl = (void *)mbd;
- u16 writeEUN;
- unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
- size_t retlen;
- struct nftl_oob oob;
-
- writeEUN = NFTL_findwriteunit(nftl, block);
-
- if (writeEUN == BLOCK_NIL) {
- printk(KERN_WARNING
- "NFTL_writeblock(): Cannot find block to write to\n");
- /* If we _still_ haven't got a block to use, we're screwed */
- return 1;
- }
-
- memset(&oob, 0xff, sizeof(struct nftl_oob));
- oob.b.Status = oob.b.Status1 = SECTOR_USED;
-
- nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs,
- 512, &retlen, (char *)buffer, (char *)&oob);
- return 0;
-}
-#endif /* CONFIG_NFTL_RW */
-
-static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
- char *buffer)
-{
- struct NFTLrecord *nftl = (void *)mbd;
- struct mtd_info *mtd = nftl->mbd.mtd;
- u16 lastgoodEUN;
- u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
- unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
- unsigned int status;
- int silly = MAX_LOOPS;
- size_t retlen;
- struct nftl_bci bci;
-
- lastgoodEUN = BLOCK_NIL;
-
- if (thisEUN != BLOCK_NIL) {
- while (thisEUN < nftl->nb_blocks) {
- if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) +
- blockofs, 8, &retlen,
- (char *)&bci) < 0)
- status = SECTOR_IGNORE;
- else
- status = bci.Status | bci.Status1;
-
- switch (status) {
- case SECTOR_FREE:
- /* no modification of a sector should follow a free sector */
- goto the_end;
- case SECTOR_DELETED:
- lastgoodEUN = BLOCK_NIL;
- break;
- case SECTOR_USED:
- lastgoodEUN = thisEUN;
- break;
- case SECTOR_IGNORE:
- break;
- default:
- printk("Unknown status for block %ld in EUN %d: %x\n",
- block, thisEUN, status);
- break;
- }
-
- if (!silly--) {
- printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n",
- block / (nftl->EraseSize / 512));
- return 1;
- }
- thisEUN = nftl->ReplUnitTable[thisEUN];
- }
- }
-
- the_end:
- if (lastgoodEUN == BLOCK_NIL) {
- /* the requested block is not on the media, return all 0x00 */
- memset(buffer, 0, 512);
- } else {
- loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
- size_t retlen;
- int res = mtd_read(mtd, ptr, 512, &retlen, buffer);
-
- if (res < 0 && !mtd_is_bitflip(res))
- return -EIO;
- }
- return 0;
-}
-
-static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
-{
- struct NFTLrecord *nftl = (void *)dev;
-
- geo->heads = nftl->heads;
- geo->sectors = nftl->sectors;
- geo->cylinders = nftl->cylinders;
-
- return 0;
-}
-
-/****************************************************************************
- *
- * Module stuff
- *
- ****************************************************************************/
-
-
-static struct mtd_blktrans_ops nftl_tr = {
- .name = "nftl",
- .major = NFTL_MAJOR,
- .part_bits = NFTL_PARTN_BITS,
- .blksize = 512,
- .getgeo = nftl_getgeo,
- .readsect = nftl_readblock,
-#ifdef CONFIG_NFTL_RW
- .writesect = nftl_writeblock,
-#endif
- .add_mtd = nftl_add_mtd,
- .remove_dev = nftl_remove_dev,
- .owner = THIS_MODULE,
-};
-
-static int __init init_nftl(void)
-{
- return register_mtd_blktrans(&nftl_tr);
-}
-
-static void __exit cleanup_nftl(void)
-{
- deregister_mtd_blktrans(&nftl_tr);
-}
-
-module_init(init_nftl);
-module_exit(cleanup_nftl);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("David Woodhouse <dwmw2 at infradead.org>, Fabrice Bellard <fabrice.bellard at netgem.com> et al.");
-MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");
-MODULE_ALIAS_BLOCKDEV_MAJOR(NFTL_MAJOR);
diff --git a/drivers/mtd/nftlmount.c b/drivers/mtd/nftlmount.c
deleted file mode 100644
index 51b9d6a..0000000
--- a/drivers/mtd/nftlmount.c
+++ /dev/null
@@ -1,786 +0,0 @@
-/*
- * NFTL mount code with extensive checks
- *
- * Author: Fabrice Bellard (fabrice.bellard at netgem.com)
- * Copyright © 2000 Netgem S.A.
- * Copyright © 1999-2010 David Woodhouse <dwmw2 at infradead.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include <linux/kernel.h>
-#include <asm/errno.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/nand.h>
-#include <linux/mtd/nftl.h>
-
-#define SECTORSIZE 512
-
-/* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
- * various device information of the NFTL partition and Bad Unit Table. Update
- * the ReplUnitTable[] table according to the Bad Unit Table. ReplUnitTable[]
- * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
- */
-static int find_boot_record(struct NFTLrecord *nftl)
-{
- struct nftl_uci1 h1;
- unsigned int block, boot_record_count = 0;
- size_t retlen;
- u8 buf[SECTORSIZE];
- struct NFTLMediaHeader *mh = &nftl->MediaHdr;
- struct mtd_info *mtd = nftl->mbd.mtd;
- unsigned int i;
-
- /* Assume logical EraseSize == physical erasesize for starting the scan.
- We'll sort it out later if we find a MediaHeader which says otherwise */
- /* Actually, we won't. The new DiskOnChip driver has already scanned
- the MediaHeader and adjusted the virtual erasesize it presents in
- the mtd device accordingly. We could even get rid of
- nftl->EraseSize if there were any point in doing so. */
- nftl->EraseSize = nftl->mbd.mtd->erasesize;
- nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
-
- nftl->MediaUnit = BLOCK_NIL;
- nftl->SpareMediaUnit = BLOCK_NIL;
-
- /* search for a valid boot record */
- for (block = 0; block < nftl->nb_blocks; block++) {
- int ret;
-
- /* Check for ANAND header first. Then can whinge if it's found but later
- checks fail */
- ret = mtd_read(mtd, block * nftl->EraseSize, SECTORSIZE,
- &retlen, buf);
- /* We ignore ret in case the ECC of the MediaHeader is invalid
- (which is apparently acceptable) */
- if (retlen != SECTORSIZE) {
- static int warncount = 5;
-
- if (warncount) {
- printk(KERN_WARNING "Block read at 0x%x of mtd%d failed: %d\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
- if (!--warncount)
- printk(KERN_WARNING "Further failures for this block will not be printed\n");
- }
- continue;
- }
-
- if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
- /* ANAND\0 not found. Continue */
-#if 0
- printk(KERN_DEBUG "ANAND header not found at 0x%x in mtd%d\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index);
-#endif
- continue;
- }
-
- /* To be safer with BIOS, also use erase mark as discriminant */
- if ((ret = nftl_read_oob(mtd, block * nftl->EraseSize +
- SECTORSIZE + 8, 8, &retlen,
- (char *)&h1) < 0)) {
- printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
- continue;
- }
-
-#if 0 /* Some people seem to have devices without ECC or erase marks
- on the Media Header blocks. There are enough other sanity
- checks in here that we can probably do without it.
- */
- if (le16_to_cpu(h1.EraseMark | h1.EraseMark1) != ERASE_MARK) {
- printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but erase mark not present (0x%04x,0x%04x instead)\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index,
- le16_to_cpu(h1.EraseMark), le16_to_cpu(h1.EraseMark1));
- continue;
- }
-
- /* Finally reread to check ECC */
- if ((ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
- &retlen, buf) < 0)) {
- printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
- continue;
- }
-
- /* Paranoia. Check the ANAND header is still there after the ECC read */
- if (memcmp(buf, "ANAND", 6)) {
- printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but went away on reread!\n",
- block * nftl->EraseSize, nftl->mbd.mtd->index);
- printk(KERN_NOTICE "New data are: %02x %02x %02x %02x %02x %02x\n",
- buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
- continue;
- }
-#endif
- /* OK, we like it. */
-
- if (boot_record_count) {
- /* We've already processed one. So we just check if
- this one is the same as the first one we found */
- if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
- printk(KERN_NOTICE "NFTL Media Headers at 0x%x and 0x%x disagree.\n",
- nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
- /* if (debug) Print both side by side */
- if (boot_record_count < 2) {
- /* We haven't yet seen two real ones */
- return -1;
- }
- continue;
- }
- if (boot_record_count == 1)
- nftl->SpareMediaUnit = block;
-
- /* Mark this boot record (NFTL MediaHeader) block as reserved */
- nftl->ReplUnitTable[block] = BLOCK_RESERVED;
-
-
- boot_record_count++;
- continue;
- }
-
- /* This is the first we've seen. Copy the media header structure into place */
- memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
-
- /* Do some sanity checks on it */
-#if 0
-The new DiskOnChip driver scans the MediaHeader itself, and presents a virtual
-erasesize based on UnitSizeFactor. So the erasesize we read from the mtd
-device is already correct.
- if (mh->UnitSizeFactor == 0) {
- printk(KERN_NOTICE "NFTL: UnitSizeFactor 0x00 detected. This violates the spec but we think we know what it means...\n");
- } else if (mh->UnitSizeFactor < 0xfc) {
- printk(KERN_NOTICE "Sorry, we don't support UnitSizeFactor 0x%02x\n",
- mh->UnitSizeFactor);
- return -1;
- } else if (mh->UnitSizeFactor != 0xff) {
- printk(KERN_NOTICE "WARNING: Support for NFTL with UnitSizeFactor 0x%02x is experimental\n",
- mh->UnitSizeFactor);
- nftl->EraseSize = nftl->mbd.mtd->erasesize << (0xff - mh->UnitSizeFactor);
- nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
- }
-#endif
- nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
- if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
- printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
- printk(KERN_NOTICE "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
- nftl->nb_boot_blocks, nftl->nb_blocks);
- return -1;
- }
-
- nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
- if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
- printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
- printk(KERN_NOTICE "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
- nftl->numvunits, nftl->nb_blocks, nftl->nb_boot_blocks);
- return -1;
- }
-
- nftl->mbd.size = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
-
- /* If we're not using the last sectors in the device for some reason,
- reduce nb_blocks accordingly so we forget they're there */
- nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
-
- /* XXX: will be suppressed */
- nftl->lastEUN = nftl->nb_blocks - 1;
-
- /* memory alloc */
- nftl->EUNtable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
- if (!nftl->EUNtable) {
- printk(KERN_NOTICE "NFTL: allocation of EUNtable failed\n");
- return -ENOMEM;
- }
-
- nftl->ReplUnitTable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
- if (!nftl->ReplUnitTable) {
- kfree(nftl->EUNtable);
- printk(KERN_NOTICE "NFTL: allocation of ReplUnitTable failed\n");
- return -ENOMEM;
- }
-
- /* mark the bios blocks (blocks before NFTL MediaHeader) as reserved */
- for (i = 0; i < nftl->nb_boot_blocks; i++)
- nftl->ReplUnitTable[i] = BLOCK_RESERVED;
- /* mark all remaining blocks as potentially containing data */
- for (; i < nftl->nb_blocks; i++) {
- nftl->ReplUnitTable[i] = BLOCK_NOTEXPLORED;
- }
-
- /* Mark this boot record (NFTL MediaHeader) block as reserved */
- nftl->ReplUnitTable[block] = BLOCK_RESERVED;
-
- /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
- for (i = 0; i < nftl->nb_blocks; i++) {
-#if 0
-The new DiskOnChip driver already scanned the bad block table. Just query it.
- if ((i & (SECTORSIZE - 1)) == 0) {
- /* read one sector for every SECTORSIZE of blocks */
- if ((ret = mtd->read(nftl->mbd.mtd, block * nftl->EraseSize +
- i + SECTORSIZE, SECTORSIZE, &retlen,
- buf)) < 0) {
- printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
- ret);
- kfree(nftl->ReplUnitTable);
- kfree(nftl->EUNtable);
- return -1;
- }
- }
- /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
- if (buf[i & (SECTORSIZE - 1)] != 0xff)
- nftl->ReplUnitTable[i] = BLOCK_RESERVED;
-#endif
- if (mtd_block_isbad(nftl->mbd.mtd,
- i * nftl->EraseSize))
- nftl->ReplUnitTable[i] = BLOCK_RESERVED;
- }
-
- nftl->MediaUnit = block;
- boot_record_count++;
-
- } /* foreach (block) */
-
- return boot_record_count?0:-1;
-}
-
-static int memcmpb(void *a, int c, int n)
-{
- int i;
- for (i = 0; i < n; i++) {
- if (c != ((unsigned char *)a)[i])
- return 1;
- }
- return 0;
-}
-
-/* check_free_sector: check if a free sector is actually FREE, i.e. All 0xff in data and oob area */
-static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
- int check_oob)
-{
- u8 buf[SECTORSIZE + nftl->mbd.mtd->oobsize];
- struct mtd_info *mtd = nftl->mbd.mtd;
- size_t retlen;
- int i;
-
- for (i = 0; i < len; i += SECTORSIZE) {
- if (mtd_read(mtd, address, SECTORSIZE, &retlen, buf))
- return -1;
- if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
- return -1;
-
- if (check_oob) {
- if(nftl_read_oob(mtd, address, mtd->oobsize,
- &retlen, &buf[SECTORSIZE]) < 0)
- return -1;
- if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
- return -1;
- }
- address += SECTORSIZE;
- }
-
- return 0;
-}
-
-/* NFTL_format: format a Erase Unit by erasing ALL Erase Zones in the Erase Unit and
- * Update NFTL metadata. Each erase operation is checked with check_free_sectors
- *
- * Return: 0 when succeed, -1 on error.
- *
- * ToDo: 1. Is it necessary to check_free_sector after erasing ??
- */
-int NFTL_formatblock(struct NFTLrecord *nftl, int block)
-{
- size_t retlen;
- unsigned int nb_erases, erase_mark;
- struct nftl_uci1 uci;
- struct erase_info *instr = &nftl->instr;
- struct mtd_info *mtd = nftl->mbd.mtd;
-
- /* Read the Unit Control Information #1 for Wear-Leveling */
- if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8,
- 8, &retlen, (char *)&uci) < 0)
- goto default_uci1;
-
- erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
- if (erase_mark != ERASE_MARK) {
- default_uci1:
- uci.EraseMark = cpu_to_le16(ERASE_MARK);
- uci.EraseMark1 = cpu_to_le16(ERASE_MARK);
- uci.WearInfo = cpu_to_le32(0);
- }
-
- memset(instr, 0, sizeof(struct erase_info));
-
- /* XXX: use async erase interface, XXX: test return code */
- instr->mtd = nftl->mbd.mtd;
- instr->addr = block * nftl->EraseSize;
- instr->len = nftl->EraseSize;
- mtd_erase(mtd, instr);
-
- if (instr->state == MTD_ERASE_FAILED) {
- printk("Error while formatting block %d\n", block);
- goto fail;
- }
-
- /* increase and write Wear-Leveling info */
- nb_erases = le32_to_cpu(uci.WearInfo);
- nb_erases++;
-
- /* wrap (almost impossible with current flash) or free block */
- if (nb_erases == 0)
- nb_erases = 1;
-
- /* check the "freeness" of Erase Unit before updating metadata
- * FixMe: is this check really necessary ? since we have check the
- * return code after the erase operation. */
- if (check_free_sectors(nftl, instr->addr, nftl->EraseSize, 1) != 0)
- goto fail;
-
- uci.WearInfo = le32_to_cpu(nb_erases);
- if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE +
- 8, 8, &retlen, (char *)&uci) < 0)
- goto fail;
- return 0;
-fail:
- /* could not format, update the bad block table (caller is responsible
- for setting the ReplUnitTable to BLOCK_RESERVED on failure) */
- mtd_block_markbad(nftl->mbd.mtd, instr->addr);
- return -1;
-}
-
-/* check_sectors_in_chain: Check that each sector of a Virtual Unit Chain is correct.
- * Mark as 'IGNORE' each incorrect sector. This check is only done if the chain
- * was being folded when NFTL was interrupted.
- *
- * The check_free_sectors in this function is necessary. There is a possible
- * situation that after writing the Data area, the Block Control Information is
- * not updated according (due to power failure or something) which leaves the block
- * in an inconsistent state. So we have to check if a block is really FREE in this
- * case. */
-static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
-{
- struct mtd_info *mtd = nftl->mbd.mtd;
- unsigned int block, i, status;
- struct nftl_bci bci;
- int sectors_per_block;
- size_t retlen;
-
- sectors_per_block = nftl->EraseSize / SECTORSIZE;
- block = first_block;
- for (;;) {
- for (i = 0; i < sectors_per_block; i++) {
- if (nftl_read_oob(mtd,
- block * nftl->EraseSize + i * SECTORSIZE,
- 8, &retlen, (char *)&bci) < 0)
- status = SECTOR_IGNORE;
- else
- status = bci.Status | bci.Status1;
-
- switch(status) {
- case SECTOR_FREE:
- /* verify that the sector is really free. If not, mark
- as ignore */
- if (memcmpb(&bci, 0xff, 8) != 0 ||
- check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE,
- SECTORSIZE, 0) != 0) {
- printk("Incorrect free sector %d in block %d: "
- "marking it as ignored\n",
- i, block);
-
- /* sector not free actually : mark it as SECTOR_IGNORE */
- bci.Status = SECTOR_IGNORE;
- bci.Status1 = SECTOR_IGNORE;
- nftl_write_oob(mtd, block *
- nftl->EraseSize +
- i * SECTORSIZE, 8,
- &retlen, (char *)&bci);
- }
- break;
- default:
- break;
- }
- }
-
- /* proceed to next Erase Unit on the chain */
- block = nftl->ReplUnitTable[block];
- if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
- printk("incorrect ReplUnitTable[] : %d\n", block);
- if (block == BLOCK_NIL || block >= nftl->nb_blocks)
- break;
- }
-}
-
-/* calc_chain_length: Walk through a Virtual Unit Chain and estimate chain length */
-static int calc_chain_length(struct NFTLrecord *nftl, unsigned int first_block)
-{
- unsigned int length = 0, block = first_block;
-
- for (;;) {
- length++;
- /* avoid infinite loops, although this is guaranteed not to
- happen because of the previous checks */
- if (length >= nftl->nb_blocks) {
- printk("nftl: length too long %d !\n", length);
- break;
- }
-
- block = nftl->ReplUnitTable[block];
- if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
- printk("incorrect ReplUnitTable[] : %d\n", block);
- if (block == BLOCK_NIL || block >= nftl->nb_blocks)
- break;
- }
- return length;
-}
-
-/* format_chain: Format an invalid Virtual Unit chain. It frees all the Erase Units in a
- * Virtual Unit Chain, i.e. all the units are disconnected.
- *
- * It is not strictly correct to begin from the first block of the chain because
- * if we stop the code, we may see again a valid chain if there was a first_block
- * flag in a block inside it. But is it really a problem ?
- *
- * FixMe: Figure out what the last statement means. What if power failure when we are
- * in the for (;;) loop formatting blocks ??
- */
-static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
-{
- unsigned int block = first_block, block1;
-
- printk("Formatting chain at block %d\n", first_block);
-
- for (;;) {
- block1 = nftl->ReplUnitTable[block];
-
- printk("Formatting block %d\n", block);
- if (NFTL_formatblock(nftl, block) < 0) {
- /* cannot format !!!! Mark it as Bad Unit */
- nftl->ReplUnitTable[block] = BLOCK_RESERVED;
- } else {
- nftl->ReplUnitTable[block] = BLOCK_FREE;
- }
-
- /* goto next block on the chain */
- block = block1;
-
- if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
- printk("incorrect ReplUnitTable[] : %d\n", block);
- if (block == BLOCK_NIL || block >= nftl->nb_blocks)
- break;
- }
-}
-
-/* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or
- * totally free (only 0xff).
- *
- * Definition: Free Erase Unit -- A properly erased/formatted Free Erase Unit should have meet the
- * following criteria:
- * 1. */
-static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
-{
- struct mtd_info *mtd = nftl->mbd.mtd;
- struct nftl_uci1 h1;
- unsigned int erase_mark;
- size_t retlen;
-
- /* check erase mark. */
- if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
- &retlen, (char *)&h1) < 0)
- return -1;
-
- erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
- if (erase_mark != ERASE_MARK) {
- /* if no erase mark, the block must be totally free. This is
- possible in two cases : empty filesystem or interrupted erase (very unlikely) */
- if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0)
- return -1;
-
- /* free block : write erase mark */
- h1.EraseMark = cpu_to_le16(ERASE_MARK);
- h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
- h1.WearInfo = cpu_to_le32(0);
- if (nftl_write_oob(mtd,
- block * nftl->EraseSize + SECTORSIZE + 8, 8,
- &retlen, (char *)&h1) < 0)
- return -1;
- } else {
-#if 0
- /* if erase mark present, need to skip it when doing check */
- for (i = 0; i < nftl->EraseSize; i += SECTORSIZE) {
- /* check free sector */
- if (check_free_sectors (nftl, block * nftl->EraseSize + i,
- SECTORSIZE, 0) != 0)
- return -1;
-
- if (nftl_read_oob(mtd, block * nftl->EraseSize + i,
- 16, &retlen, buf) < 0)
- return -1;
- if (i == SECTORSIZE) {
- /* skip erase mark */
- if (memcmpb(buf, 0xff, 8))
- return -1;
- } else {
- if (memcmpb(buf, 0xff, 16))
- return -1;
- }
- }
-#endif
- }
-
- return 0;
-}
-
-/* get_fold_mark: Read fold mark from Unit Control Information #2, we use FOLD_MARK_IN_PROGRESS
- * to indicate that we are in the progression of a Virtual Unit Chain folding. If the UCI #2
- * is FOLD_MARK_IN_PROGRESS when mounting the NFTL, the (previous) folding process is interrupted
- * for some reason. A clean up/check of the VUC is necessary in this case.
- *
- * WARNING: return 0 if read error
- */
-static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
-{
- struct mtd_info *mtd = nftl->mbd.mtd;
- struct nftl_uci2 uci;
- size_t retlen;
-
- if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
- 8, &retlen, (char *)&uci) < 0)
- return 0;
-
- return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
-}
-
-int NFTL_mount(struct NFTLrecord *s)
-{
- int i;
- unsigned int first_logical_block, logical_block, rep_block, nb_erases, erase_mark;
- unsigned int block, first_block, is_first_block;
- int chain_length, do_format_chain;
- struct nftl_uci0 h0;
- struct nftl_uci1 h1;
- struct mtd_info *mtd = s->mbd.mtd;
- size_t retlen;
-
- /* search for NFTL MediaHeader and Spare NFTL Media Header */
- if (find_boot_record(s) < 0) {
- printk("Could not find valid boot record\n");
- return -1;
- }
-
- /* init the logical to physical table */
- for (i = 0; i < s->nb_blocks; i++) {
- s->EUNtable[i] = BLOCK_NIL;
- }
-
- /* first pass : explore each block chain */
- first_logical_block = 0;
- for (first_block = 0; first_block < s->nb_blocks; first_block++) {
- /* if the block was not already explored, we can look at it */
- if (s->ReplUnitTable[first_block] == BLOCK_NOTEXPLORED) {
- block = first_block;
- chain_length = 0;
- do_format_chain = 0;
-
- for (;;) {
- /* read the block header. If error, we format the chain */
- if (nftl_read_oob(mtd,
- block * s->EraseSize + 8, 8,
- &retlen, (char *)&h0) < 0 ||
- nftl_read_oob(mtd,
- block * s->EraseSize +
- SECTORSIZE + 8, 8,
- &retlen, (char *)&h1) < 0) {
- s->ReplUnitTable[block] = BLOCK_NIL;
- do_format_chain = 1;
- break;
- }
-
- logical_block = le16_to_cpu ((h0.VirtUnitNum | h0.SpareVirtUnitNum));
- rep_block = le16_to_cpu ((h0.ReplUnitNum | h0.SpareReplUnitNum));
- nb_erases = le32_to_cpu (h1.WearInfo);
- erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
-
- is_first_block = !(logical_block >> 15);
- logical_block = logical_block & 0x7fff;
-
- /* invalid/free block test */
- if (erase_mark != ERASE_MARK || logical_block >= s->nb_blocks) {
- if (chain_length == 0) {
- /* if not currently in a chain, we can handle it safely */
- if (check_and_mark_free_block(s, block) < 0) {
- /* not really free: format it */
- printk("Formatting block %d\n", block);
- if (NFTL_formatblock(s, block) < 0) {
- /* could not format: reserve the block */
- s->ReplUnitTable[block] = BLOCK_RESERVED;
- } else {
- s->ReplUnitTable[block] = BLOCK_FREE;
- }
- } else {
- /* free block: mark it */
- s->ReplUnitTable[block] = BLOCK_FREE;
- }
- /* directly examine the next block. */
- goto examine_ReplUnitTable;
- } else {
- /* the block was in a chain : this is bad. We
- must format all the chain */
- printk("Block %d: free but referenced in chain %d\n",
- block, first_block);
- s->ReplUnitTable[block] = BLOCK_NIL;
- do_format_chain = 1;
- break;
- }
- }
-
- /* we accept only first blocks here */
- if (chain_length == 0) {
- /* this block is not the first block in chain :
- ignore it, it will be included in a chain
- later, or marked as not explored */
- if (!is_first_block)
- goto examine_ReplUnitTable;
- first_logical_block = logical_block;
- } else {
- if (logical_block != first_logical_block) {
- printk("Block %d: incorrect logical block: %d expected: %d\n",
- block, logical_block, first_logical_block);
- /* the chain is incorrect : we must format it,
- but we need to read it completely */
- do_format_chain = 1;
- }
- if (is_first_block) {
- /* we accept that a block is marked as first
- block while being last block in a chain
- only if the chain is being folded */
- if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS ||
- rep_block != 0xffff) {
- printk("Block %d: incorrectly marked as first block in chain\n",
- block);
- /* the chain is incorrect : we must format it,
- but we need to read it completely */
- do_format_chain = 1;
- } else {
- printk("Block %d: folding in progress - ignoring first block flag\n",
- block);
- }
- }
- }
- chain_length++;
- if (rep_block == 0xffff) {
- /* no more blocks after */
- s->ReplUnitTable[block] = BLOCK_NIL;
- break;
- } else if (rep_block >= s->nb_blocks) {
- printk("Block %d: referencing invalid block %d\n",
- block, rep_block);
- do_format_chain = 1;
- s->ReplUnitTable[block] = BLOCK_NIL;
- break;
- } else if (s->ReplUnitTable[rep_block] != BLOCK_NOTEXPLORED) {
- /* same problem as previous 'is_first_block' test:
- we accept that the last block of a chain has
- the first_block flag set if folding is in
- progress. We handle here the case where the
- last block appeared first */
- if (s->ReplUnitTable[rep_block] == BLOCK_NIL &&
- s->EUNtable[first_logical_block] == rep_block &&
- get_fold_mark(s, first_block) == FOLD_MARK_IN_PROGRESS) {
- /* EUNtable[] will be set after */
- printk("Block %d: folding in progress - ignoring first block flag\n",
- rep_block);
- s->ReplUnitTable[block] = rep_block;
- s->EUNtable[first_logical_block] = BLOCK_NIL;
- } else {
- printk("Block %d: referencing block %d already in another chain\n",
- block, rep_block);
- /* XXX: should handle correctly fold in progress chains */
- do_format_chain = 1;
- s->ReplUnitTable[block] = BLOCK_NIL;
- }
- break;
- } else {
- /* this is OK */
- s->ReplUnitTable[block] = rep_block;
- block = rep_block;
- }
- }
-
- /* the chain was completely explored. Now we can decide
- what to do with it */
- if (do_format_chain) {
- /* invalid chain : format it */
- format_chain(s, first_block);
- } else {
- unsigned int first_block1, chain_to_format, chain_length1;
- int fold_mark;
-
- /* valid chain : get foldmark */
- fold_mark = get_fold_mark(s, first_block);
- if (fold_mark == 0) {
- /* cannot get foldmark : format the chain */
- printk("Could read foldmark at block %d\n", first_block);
- format_chain(s, first_block);
- } else {
- if (fold_mark == FOLD_MARK_IN_PROGRESS)
- check_sectors_in_chain(s, first_block);
-
- /* now handle the case where we find two chains at the
- same virtual address : we select the longer one,
- because the shorter one is the one which was being
- folded if the folding was not done in place */
- first_block1 = s->EUNtable[first_logical_block];
- if (first_block1 != BLOCK_NIL) {
- /* XXX: what to do if same length ? */
- chain_length1 = calc_chain_length(s, first_block1);
- printk("Two chains at blocks %d (len=%d) and %d (len=%d)\n",
- first_block1, chain_length1, first_block, chain_length);
-
- if (chain_length >= chain_length1) {
- chain_to_format = first_block1;
- s->EUNtable[first_logical_block] = first_block;
- } else {
- chain_to_format = first_block;
- }
- format_chain(s, chain_to_format);
- } else {
- s->EUNtable[first_logical_block] = first_block;
- }
- }
- }
- }
- examine_ReplUnitTable:;
- }
-
- /* second pass to format unreferenced blocks and init free block count */
- s->numfreeEUNs = 0;
- s->LastFreeEUN = le16_to_cpu(s->MediaHdr.FirstPhysicalEUN);
-
- for (block = 0; block < s->nb_blocks; block++) {
- if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) {
- printk("Unreferenced block %d, formatting it\n", block);
- if (NFTL_formatblock(s, block) < 0)
- s->ReplUnitTable[block] = BLOCK_RESERVED;
- else
- s->ReplUnitTable[block] = BLOCK_FREE;
- }
- if (s->ReplUnitTable[block] == BLOCK_FREE) {
- s->numfreeEUNs++;
- s->LastFreeEUN = block;
- }
- }
-
- return 0;
-}
--
1.7.10.4
More information about the linux-mtd
mailing list