Remove obsolete pathDivider field

[yaffs2.git] / yaffs_checkptrw.c

diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 481b0327f46180302335039eb8012153e146cc24..7ae263caae8c7b7000fda09db4e5efe480c28a28 100644 (file)
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -12,7 +12,7 @@
  */
 
 const char *yaffs_checkptrw_c_version =
-       "$Id: yaffs_checkptrw.c,v 1.21 2009-10-29 03:05:55 charles Exp $";
+       "$Id: yaffs_checkptrw.c,v 1.23 2010-02-18 01:18:04 charles Exp $";
 
 
 #include "yaffs_checkptrw.h"
@@ -20,7 +20,7 @@ const char *yaffs_checkptrw_c_version =
 
 static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
 {
-       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
+       int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks;
 
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("checkpt blocks available = %d" TENDSTR),
@@ -34,7 +34,7 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
 {
        int i;
 
-       if (!dev->eraseBlockInNAND)
+       if (!dev->param.eraseBlockInNAND)
                return 0;
        T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR),
                dev->internalStartBlock, dev->internalEndBlock));
@@ -46,12 +46,12 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
 
                        dev->nBlockErasures++;
 
-                       if (dev->eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) {
+                       if (dev->param.eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) {
                                bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
                                dev->nErasedBlocks++;
-                               dev->nFreeChunks += dev->nChunksPerBlock;
+                               dev->nFreeChunks += dev->param.nChunksPerBlock;
                        } else {
-                               dev->markNANDBlockBad(dev, i);
+                               dev->param.markNANDBlockBad(dev, i);
                                bi->blockState = YAFFS_BLOCK_STATE_DEAD;
                        }
                }
@@ -66,10 +66,10 @@ static int yaffs_CheckpointErase(yaffs_Device *dev)
 static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
 {
        int  i;
-       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
+       int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks;
        T(YAFFS_TRACE_CHECKPOINT,
                (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
-               dev->nErasedBlocks, dev->nReservedBlocks, blocksAvailable, dev->checkpointNextBlock));
+               dev->nErasedBlocks, dev->param.nReservedBlocks, blocksAvailable, dev->checkpointNextBlock));
 
        if (dev->checkpointNextBlock >= 0 &&
                        dev->checkpointNextBlock <= dev->internalEndBlock &&
@@ -101,10 +101,10 @@ static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
 
        if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
                for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) {
-                       int chunk = i * dev->nChunksPerBlock;
+                       int chunk = i * dev->param.nChunksPerBlock;
                        int realignedChunk = chunk - dev->chunkOffset;
 
-                       dev->readChunkWithTagsFromNAND(dev, realignedChunk,
+                       dev->param.readChunkWithTagsFromNAND(dev, realignedChunk,
                                        NULL, &tags);
                        T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
                                i, tags.objectId, tags.sequenceNumber, tags.eccResult));
@@ -134,17 +134,17 @@ int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
        dev->checkpointOpenForWrite = forWriting;
 
        /* Got the functions we need? */
-       if (!dev->writeChunkWithTagsToNAND ||
-                       !dev->readChunkWithTagsFromNAND ||
-                       !dev->eraseBlockInNAND ||
-                       !dev->markNANDBlockBad)
+       if (!dev->param.writeChunkWithTagsToNAND ||
+               !dev->param.readChunkWithTagsFromNAND ||
+               !dev->param.eraseBlockInNAND ||
+               !dev->param.markNANDBlockBad)
                return 0;
 
        if (forWriting && !yaffs_CheckpointSpaceOk(dev))
                return 0;
 
        if (!dev->checkpointBuffer)
-               dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk);
+               dev->checkpointBuffer = YMALLOC_DMA(dev->param.totalBytesPerChunk);
        if (!dev->checkpointBuffer)
                return 0;
 
@@ -217,7 +217,7 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
                dev->blocksInCheckpoint++;
        }
 
-       chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
+       chunk = dev->checkpointCurrentBlock * dev->param.nChunksPerBlock + dev->checkpointCurrentChunk;
 
 
        T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
@@ -227,12 +227,12 @@ static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
 
        dev->nPageWrites++;
 
-       dev->writeChunkWithTagsToNAND(dev, realignedChunk,
+       dev->param.writeChunkWithTagsToNAND(dev, realignedChunk,
                        dev->checkpointBuffer, &tags);
        dev->checkpointByteOffset = 0;
        dev->checkpointPageSequence++;
        dev->checkpointCurrentChunk++;
-       if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock) {
+       if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) {
                dev->checkpointCurrentChunk = 0;
                dev->checkpointCurrentBlock = -1;
        }
@@ -310,7 +310,7 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                                ok = 0;
                        else {
                                chunk = dev->checkpointCurrentBlock *
-                                       dev->nChunksPerBlock +
+                                       dev->param.nChunksPerBlock +
                                        dev->checkpointCurrentChunk;
 
                                realignedChunk = chunk - dev->chunkOffset;
@@ -319,7 +319,7 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
 
                                /* read in the next chunk */
                                /* printf("read checkpoint page %d\n",dev->checkpointPage); */
-                               dev->readChunkWithTagsFromNAND(dev,
+                               dev->param.readChunkWithTagsFromNAND(dev,
                                                realignedChunk,
                                                dev->checkpointBuffer,
                                                &tags);
@@ -333,7 +333,7 @@ int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
                                dev->checkpointPageSequence++;
                                dev->checkpointCurrentChunk++;
 
-                               if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
+                               if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock)
                                        dev->checkpointCurrentBlock = -1;
                        }
                }
@@ -375,7 +375,7 @@ int yaffs_CheckpointClose(yaffs_Device *dev)
                dev->checkpointBlockList = NULL;
        }
 
-       dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
+       dev->nFreeChunks -= dev->blocksInCheckpoint * dev->param.nChunksPerBlock;
        dev->nErasedBlocks -= dev->blocksInCheckpoint;
 
 
@@ -395,7 +395,8 @@ int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
 {
        /* Erase the checkpoint data */
 
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate"TENDSTR)));
+       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR),
+               dev->blocksInCheckpoint));
 
        return yaffs_CheckpointErase(dev);
 }