Add remount and forced unmount to yaffs direct
[yaffs2.git] / yaffs_tagscompat.c
index d594d61..020eee5 100644 (file)
 #include "yaffs_guts.h"
 #include "yaffs_tagscompat.h"
 #include "yaffs_ecc.h"
+#include "yaffs_getblockinfo.h"
+#include "yaffs_trace.h"
 
-static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
+static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND);
 #ifdef NOTYET
-static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_Spare * spare);
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_Spare * spare);
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
+static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND);
+static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
+                                    const __u8 *data,
+                                    const yaffs_Spare *spare);
+static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
+                                   const yaffs_Spare *spare);
+static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND);
 #endif
 
 static const char yaffs_countBitsTable[256] = {
@@ -45,7 +47,7 @@ static const char yaffs_countBitsTable[256] = {
        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
 };
 
-static int yaffs_CountBits(__u8 x)
+int yaffs_CountBits(__u8 x)
 {
        int retVal;
        retVal = yaffs_countBitsTable[x];
@@ -54,13 +56,13 @@ static int yaffs_CountBits(__u8 x)
 
 /********** Tags ECC calculations  *********/
 
-void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
+void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
 {
        yaffs_ECCCalculate(data, spare->ecc1);
        yaffs_ECCCalculate(&data[256], spare->ecc2);
 }
 
-void yaffs_CalcTagsECC(yaffs_Tags * tags)
+void yaffs_CalcTagsECC(yaffs_Tags *tags)
 {
        /* Calculate an ecc */
 
@@ -74,9 +76,8 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags)
        for (i = 0; i < 8; i++) {
                for (j = 1; j & 0xff; j <<= 1) {
                        bit++;
-                       if (b[i] & j) {
+                       if (b[i] & j)
                                ecc ^= bit;
-                       }
                }
        }
 
@@ -84,7 +85,7 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags)
 
 }
 
-int yaffs_CheckECCOnTags(yaffs_Tags * tags)
+int yaffs_CheckECCOnTags(yaffs_Tags *tags)
 {
        unsigned ecc = tags->ecc;
 
@@ -115,8 +116,8 @@ int yaffs_CheckECCOnTags(yaffs_Tags * tags)
 
 /********** Tags **********/
 
-static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
-                                   yaffs_Tags * tagsPtr)
+static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr,
+                               yaffs_Tags *tagsPtr)
 {
        yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
 
@@ -132,8 +133,8 @@ static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
        sparePtr->tagByte7 = tu->asBytes[7];
 }
 
-static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
-                                  yaffs_Tags * tagsPtr)
+static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr,
+                               yaffs_Tags *tagsPtr)
 {
        yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
        int result;
@@ -148,21 +149,20 @@ static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
        tu->asBytes[7] = sparePtr->tagByte7;
 
        result = yaffs_CheckECCOnTags(tagsPtr);
-       if (result > 0) {
+       if (result > 0)
                dev->tagsEccFixed++;
-       } else if (result < 0) {
+       else if (result < 0)
                dev->tagsEccUnfixed++;
-       }
 }
 
-static void yaffs_SpareInitialise(yaffs_Spare * spare)
+static void yaffs_SpareInitialise(yaffs_Spare *spare)
 {
        memset(spare, 0xFF, sizeof(yaffs_Spare));
 }
 
 static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
-                                 int chunkInNAND, const __u8 * data,
-                                 yaffs_Spare * spare)
+                               int chunkInNAND, const __u8 *data,
+                               yaffs_Spare *spare)
 {
        if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
                T(YAFFS_TRACE_ERROR,
@@ -171,22 +171,19 @@ static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
                return YAFFS_FAIL;
        }
 
-       dev->nPageWrites++;
        return dev->writeChunkToNAND(dev, chunkInNAND, data, spare);
 }
 
 static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
                                   int chunkInNAND,
-                                  __u8 * data,
-                                  yaffs_Spare * spare,
-                                  yaffs_ECCResult * eccResult,
+                                  __u8 *data,
+                                  yaffs_Spare *spare,
+                                  yaffs_ECCResult *eccResult,
                                   int doErrorCorrection)
 {
        int retVal;
        yaffs_Spare localSpare;
 
-       dev->nPageReads++;
-
        if (!spare && data) {
                /* If we don't have a real spare, then we use a local one. */
                /* Need this for the calculation of the ecc */
@@ -252,9 +249,11 @@ static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
                /* Must allocate enough memory for spare+2*sizeof(int) */
                /* for ecc results from device. */
                struct yaffs_NANDSpare nspare;
-               retVal =
-                   dev->readChunkFromNAND(dev, chunkInNAND, data,
-                                          (yaffs_Spare *) & nspare);
+
+               memset(&nspare, 0, sizeof(nspare));
+
+               retVal = dev->readChunkFromNAND(dev, chunkInNAND, data,
+                                       (yaffs_Spare *) &nspare);
                memcpy(spare, &nspare, sizeof(yaffs_Spare));
                if (data && doErrorCorrection) {
                        if (nspare.eccres1 > 0) {
@@ -302,8 +301,7 @@ static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
                                  int chunkInNAND)
 {
-
-       static int init = 0;
+       static int init;
        static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
        static __u8 data[YAFFS_BYTES_PER_CHUNK];
        /* Might as well always allocate the larger size for */
@@ -331,12 +329,12 @@ static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
  * Functions for robustisizing
  */
 
-static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
+static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND)
 {
        int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
 
        /* Mark the block for retirement */
-       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
+       yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1;
        T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
          (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
 
@@ -348,22 +346,22 @@ static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
 }
 
 #ifdef NOTYET
-static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
+static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND)
 {
 }
 
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_Spare * spare)
+static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
+                                    const __u8 *data,
+                                    const yaffs_Spare *spare)
 {
 }
 
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_Spare * spare)
+static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
+                                   const yaffs_Spare *spare)
 {
 }
 
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
+static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND)
 {
        int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
 
@@ -373,8 +371,8 @@ static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
        yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
 }
 
-static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
-                              const yaffs_Spare * s0, const yaffs_Spare * s1)
+static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1,
+                              const yaffs_Spare *s0, const yaffs_Spare *s1)
 {
 
        if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
@@ -398,28 +396,35 @@ static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
 }
 #endif                         /* NOTYET */
 
-int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
-                                                   int chunkInNAND,
-                                                   const __u8 * data,
-                                                   const yaffs_ExtendedTags *
-                                                   eTags)
+int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev,
+                                               int chunkInNAND,
+                                               const __u8 *data,
+                                               const yaffs_ExtendedTags *eTags)
 {
        yaffs_Spare spare;
        yaffs_Tags tags;
 
        yaffs_SpareInitialise(&spare);
 
-       if (eTags->chunkDeleted) {
+       if (eTags->chunkDeleted)
                spare.pageStatus = 0;
-       else {
+       else {
                tags.objectId = eTags->objectId;
                tags.chunkId = eTags->chunkId;
-               tags.byteCount = eTags->byteCount;
+
+               tags.byteCountLSB = eTags->byteCount & 0x3ff;
+
+               if (dev->nDataBytesPerChunk >= 1024)
+                       tags.byteCountMSB = (eTags->byteCount >> 10) & 3;
+               else
+                       tags.byteCountMSB = 3;
+
+
                tags.serialNumber = eTags->serialNumber;
 
-               if (!dev->useNANDECC && data) {
+               if (!dev->useNANDECC && data)
                        yaffs_CalcECC(data, &spare);
-               }
+
                yaffs_LoadTagsIntoSpare(&spare, &tags);
 
        }
@@ -427,15 +432,15 @@ int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
        return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
 }
 
-int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
+int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev,
                                                     int chunkInNAND,
-                                                    __u8 * data,
-                                                    yaffs_ExtendedTags * eTags)
+                                                    __u8 *data,
+                                                    yaffs_ExtendedTags *eTags)
 {
 
        yaffs_Spare spare;
        yaffs_Tags tags;
-       yaffs_ECCResult eccResult;
+       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN;
 
        static yaffs_Spare spareFF;
        static int init;
@@ -466,7 +471,11 @@ int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
 
                                eTags->objectId = tags.objectId;
                                eTags->chunkId = tags.chunkId;
-                               eTags->byteCount = tags.byteCount;
+                               eTags->byteCount = tags.byteCountLSB;
+
+                               if (dev->nDataBytesPerChunk >= 1024)
+                                       eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10);
+
                                eTags->serialNumber = tags.serialNumber;
                        }
                }
@@ -497,9 +506,9 @@ int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
 }
 
 int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
-                                         int blockNo, yaffs_BlockState *
-                                         state,
-                                         int *sequenceNumber)
+                                         int blockNo,
+                                         yaffs_BlockState *state,
+                                         __u32 *sequenceNumber)
 {
 
        yaffs_Spare spare0, spare1;