Move tracing out of yportenv.h

[yaffs2.git] / yaffs_packedtags2.c

diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c
index 957ed8bf0e5b19ee73fb36a72beda062a36175d9..e33e8a3ac37f1d3e118deb95624cb1243d6b5b29 100644 (file)
--- a/yaffs_packedtags2.c
+++ b/yaffs_packedtags2.c
@@ -13,6 +13,7 @@
 
 #include "yaffs_packedtags2.h"
 #include "yportenv.h"
+#include "yaffs_trace.h"
 #include "yaffs_tagsvalidity.h"
 
 /* This code packs a set of extended tags into a binary structure for
@@ -38,19 +39,19 @@
 #define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
 
 
-static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart * ptt)
+static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart *ptt)
 {
        T(YAFFS_TRACE_MTD,
          (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
           ptt->objectId, ptt->chunkId, ptt->byteCount,
           ptt->sequenceNumber));
 }
-static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
+static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt)
 {
        yaffs_DumpPackedTags2TagsPart(&pt->t);
 }
 
-static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
+static void yaffs_DumpTags2(const yaffs_ExtendedTags *t)
 {
        T(YAFFS_TRACE_MTD,
          (TSTR
@@ -61,7 +62,8 @@ static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
 
 }
 
-void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart * ptt, const yaffs_ExtendedTags * t)
+void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt,
+               const yaffs_ExtendedTags *t)
 {
        ptt->chunkId = t->chunkId;
        ptt->sequenceNumber = t->sequenceNumber;
@@ -73,24 +75,21 @@ void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart * ptt, const yaffs_Extend
                /* We save the parent object in the chunkId */
                ptt->chunkId = EXTRA_HEADER_INFO_FLAG
                        | t->extraParentObjectId;
-               if (t->extraIsShrinkHeader) {
+               if (t->extraIsShrinkHeader)
                        ptt->chunkId |= EXTRA_SHRINK_FLAG;
-               }
-               if (t->extraShadows) {
+               if (t->extraShadows)
                        ptt->chunkId |= EXTRA_SHADOWS_FLAG;
-               }
 
                ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
                ptt->objectId |=
                    (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
 
-               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
+               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
                        ptt->byteCount = t->extraEquivalentObjectId;
-               } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
+               else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE)
                        ptt->byteCount = t->extraFileLength;
-               } else {
+               else
                        ptt->byteCount = 0;
-               }
        }
 
        yaffs_DumpPackedTags2TagsPart(ptt);
@@ -98,21 +97,19 @@ void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart * ptt, const yaffs_Extend
 }
 
 
-void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
+void yaffs_PackTags2(yaffs_Device *dev, yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t)
 {
-       yaffs_PackTags2TagsPart(&pt->t,t);
+       yaffs_PackTags2TagsPart(&pt->t, t);
 
-#ifndef YAFFS_IGNORE_TAGS_ECC
-       {
+       if(!dev->noTagsECC)
                yaffs_ECCCalculateOther((unsigned char *)&pt->t,
                                        sizeof(yaffs_PackedTags2TagsPart),
                                        &pt->ecc);
-       }
-#endif
 }
 
 
-void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags * t, yaffs_PackedTags2TagsPart * ptt)
+void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t,
+               yaffs_PackedTags2TagsPart *ptt)
 {
 
        memset(t, 0, sizeof(yaffs_ExtendedTags));
@@ -146,11 +143,10 @@ void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags * t, yaffs_PackedTags2TagsPart
                            ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT;
                        t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
 
-                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
+                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
                                t->extraEquivalentObjectId = ptt->byteCount;
-                       } else {
+                       else
                                t->extraFileLength = ptt->byteCount;
-                       }
                }
        }
 
@@ -160,49 +156,43 @@ void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags * t, yaffs_PackedTags2TagsPart
 }
 
 
-void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
+void yaffs_UnpackTags2(yaffs_Device *dev, yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt)
 {
 
-       yaffs_UnpackTags2TagsPart(t,&pt->t);
+       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 
-       if (pt->t.sequenceNumber != 0xFFFFFFFF) {
-               /* Page is in use */
-#ifdef YAFFS_IGNORE_TAGS_ECC
-               {
-                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-               }
-#else
-               {
-                       yaffs_ECCOther ecc;
-                       int result;
-                       yaffs_ECCCalculateOther((unsigned char *)&pt->t,
-                                               sizeof
-                                               (yaffs_PackedTags2TagsPart),
-                                               &ecc);
-                       result =
-                           yaffs_ECCCorrectOther((unsigned char *)&pt->t,
-                                                 sizeof
-                                                 (yaffs_PackedTags2TagsPart),
-                                                 &pt->ecc, &ecc);
-                       switch(result){
-                               case 0:
-                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-                                       break;
-                               case 1:
-                                       t->eccResult = YAFFS_ECC_RESULT_FIXED;
-                                       break;
-                               case -1:
-                                       t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
-                                       break;
-                               default:
-                                       t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
-                       }
+       if (pt->t.sequenceNumber != 0xFFFFFFFF &&
+           !dev->noTagsECC){
+               /* Chunk is in use and we need to do ECC */
+               
+               yaffs_ECCOther ecc;
+               int result;
+               yaffs_ECCCalculateOther((unsigned char *)&pt->t,
+                                       sizeof(yaffs_PackedTags2TagsPart),
+                                       &ecc);
+               result = yaffs_ECCCorrectOther((unsigned char *)&pt->t,
+                                               sizeof(yaffs_PackedTags2TagsPart),
+                                               &pt->ecc, &ecc);
+               switch (result) {
+                       case 0:
+                               eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+                               break;
+                       case 1:
+                               eccResult = YAFFS_ECC_RESULT_FIXED;
+                               break;
+                       case -1:
+                               eccResult = YAFFS_ECC_RESULT_UNFIXED;
+                               break;
+                       default:
+                               eccResult = YAFFS_ECC_RESULT_UNKNOWN;
                }
-#endif
        }
 
+       yaffs_UnpackTags2TagsPart(t, &pt->t);
+
+       t->eccResult = eccResult;
+
        yaffs_DumpPackedTags2(pt);
        yaffs_DumpTags2(t);
-
 }