yaffs_tagscompat.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2007 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   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 version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include "yaffs_guts.h"
  15 #include "yaffs_tagscompat.h"
  16 #include "yaffs_ecc.h"
  17 #include "yaffs_getblockinfo.h"
  18
  19 static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
  20 #ifdef NOTYET
  21 static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
  22 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
  23                                      const __u8 * data,
  24                                      const yaffs_Spare * spare);
  25 static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
  26                                     const yaffs_Spare * spare);
  27 static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
  28 #endif
  29
  30 static const char yaffs_countBitsTable[256] = {
  31         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
  32         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  33         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  34         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  35         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  36         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  37         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  38         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  39         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  40         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  41         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  42         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  43         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  44         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  45         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  46         4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
  47 };
  48
  49 int yaffs_CountBits(__u8 x)
  50 {
  51         int retVal;
  52         retVal = yaffs_countBitsTable[x];
  53         return retVal;
  54 }
  55
  56 /********** Tags ECC calculations  *********/
  57
  58 void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
  59 {
  60         yaffs_ECCCalculate(data, spare->ecc1);
  61         yaffs_ECCCalculate(&data[256], spare->ecc2);
  62 }
  63
  64 void yaffs_CalcTagsECC(yaffs_Tags * tags)
  65 {
  66         /* Calculate an ecc */
  67
  68         unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
  69         unsigned i, j;
  70         unsigned ecc = 0;
  71         unsigned bit = 0;
  72
  73         tags->ecc = 0;
  74
  75         for (i = 0; i < 8; i++) {
  76                 for (j = 1; j & 0xff; j <<= 1) {
  77                         bit++;
  78                         if (b[i] & j) {
  79                                 ecc ^= bit;
  80                         }
  81                 }
  82         }
  83
  84         tags->ecc = ecc;
  85
  86 }
  87
  88 int yaffs_CheckECCOnTags(yaffs_Tags * tags)
  89 {
  90         unsigned ecc = tags->ecc;
  91
  92         yaffs_CalcTagsECC(tags);
  93
  94         ecc ^= tags->ecc;
  95
  96         if (ecc && ecc <= 64) {
  97                 /* TODO: Handle the failure better. Retire? */
  98                 unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
  99
 100                 ecc--;
 101
 102                 b[ecc / 8] ^= (1 << (ecc & 7));
 103
 104                 /* Now recvalc the ecc */
 105                 yaffs_CalcTagsECC(tags);
 106
 107                 return 1;       /* recovered error */
 108         } else if (ecc) {
 109                 /* Wierd ecc failure value */
 110                 /* TODO Need to do somethiong here */
 111                 return -1;      /* unrecovered error */
 112         }
 113
 114         return 0;
 115 }
 116
 117 /********** Tags **********/
 118
 119 static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
 120                                     yaffs_Tags * tagsPtr)
 121 {
 122         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
 123
 124         yaffs_CalcTagsECC(tagsPtr);
 125
 126         sparePtr->tagByte0 = tu->asBytes[0];
 127         sparePtr->tagByte1 = tu->asBytes[1];
 128         sparePtr->tagByte2 = tu->asBytes[2];
 129         sparePtr->tagByte3 = tu->asBytes[3];
 130         sparePtr->tagByte4 = tu->asBytes[4];
 131         sparePtr->tagByte5 = tu->asBytes[5];
 132         sparePtr->tagByte6 = tu->asBytes[6];
 133         sparePtr->tagByte7 = tu->asBytes[7];
 134 }
 135
 136 static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
 137                                    yaffs_Tags * tagsPtr)
 138 {
 139         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
 140         int result;
 141
 142         tu->asBytes[0] = sparePtr->tagByte0;
 143         tu->asBytes[1] = sparePtr->tagByte1;
 144         tu->asBytes[2] = sparePtr->tagByte2;
 145         tu->asBytes[3] = sparePtr->tagByte3;
 146         tu->asBytes[4] = sparePtr->tagByte4;
 147         tu->asBytes[5] = sparePtr->tagByte5;
 148         tu->asBytes[6] = sparePtr->tagByte6;
 149         tu->asBytes[7] = sparePtr->tagByte7;
 150
 151         result = yaffs_CheckECCOnTags(tagsPtr);
 152         if (result > 0) {
 153                 dev->tagsEccFixed++;
 154         } else if (result < 0) {
 155                 dev->tagsEccUnfixed++;
 156         }
 157 }
 158
 159 static void yaffs_SpareInitialise(yaffs_Spare * spare)
 160 {
 161         memset(spare, 0xFF, sizeof(yaffs_Spare));
 162 }
 163
 164 static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
 165                                   int chunkInNAND, const __u8 * data,
 166                                   yaffs_Spare * spare)
 167 {
 168         if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
 169                 T(YAFFS_TRACE_ERROR,
 170                   (TSTR("**>> yaffs chunk %d is not valid" TENDSTR),
 171                    chunkInNAND));
 172                 return YAFFS_FAIL;
 173         }
 174
 175         dev->nPageWrites++;
 176         return dev->writeChunkToNAND(dev, chunkInNAND, data, spare);
 177 }
 178
 179 static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
 180                                    int chunkInNAND,
 181                                    __u8 * data,
 182                                    yaffs_Spare * spare,
 183                                    yaffs_ECCResult * eccResult,
 184                                    int doErrorCorrection)
 185 {
 186         int retVal;
 187         yaffs_Spare localSpare;
 188
 189         dev->nPageReads++;
 190
 191         if (!spare && data) {
 192                 /* If we don't have a real spare, then we use a local one. */
 193                 /* Need this for the calculation of the ecc */
 194                 spare = &localSpare;
 195         }
 196
 197         if (!dev->useNANDECC) {
 198                 retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare);
 199                 if (data && doErrorCorrection) {
 200                         /* Do ECC correction */
 201                         /* Todo handle any errors */
 202                         int eccResult1, eccResult2;
 203                         __u8 calcEcc[3];
 204
 205                         yaffs_ECCCalculate(data, calcEcc);
 206                         eccResult1 =
 207                             yaffs_ECCCorrect(data, spare->ecc1, calcEcc);
 208                         yaffs_ECCCalculate(&data[256], calcEcc);
 209                         eccResult2 =
 210                             yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc);
 211
 212                         if (eccResult1 > 0) {
 213                                 T(YAFFS_TRACE_ERROR,
 214                                   (TSTR
 215                                    ("**>>yaffs ecc error fix performed on chunk %d:0"
 216                                     TENDSTR), chunkInNAND));
 217                                 dev->eccFixed++;
 218                         } else if (eccResult1 < 0) {
 219                                 T(YAFFS_TRACE_ERROR,
 220                                   (TSTR
 221                                    ("**>>yaffs ecc error unfixed on chunk %d:0"
 222                                     TENDSTR), chunkInNAND));
 223                                 dev->eccUnfixed++;
 224                         }
 225
 226                         if (eccResult2 > 0) {
 227                                 T(YAFFS_TRACE_ERROR,
 228                                   (TSTR
 229                                    ("**>>yaffs ecc error fix performed on chunk %d:1"
 230                                     TENDSTR), chunkInNAND));
 231                                 dev->eccFixed++;
 232                         } else if (eccResult2 < 0) {
 233                                 T(YAFFS_TRACE_ERROR,
 234                                   (TSTR
 235                                    ("**>>yaffs ecc error unfixed on chunk %d:1"
 236                                     TENDSTR), chunkInNAND));
 237                                 dev->eccUnfixed++;
 238                         }
 239
 240                         if (eccResult1 || eccResult2) {
 241                                 /* We had a data problem on this page */
 242                                 yaffs_HandleReadDataError(dev, chunkInNAND);
 243                         }
 244
 245                         if (eccResult1 < 0 || eccResult2 < 0)
 246                                 *eccResult = YAFFS_ECC_RESULT_UNFIXED;
 247                         else if (eccResult1 > 0 || eccResult2 > 0)
 248                                 *eccResult = YAFFS_ECC_RESULT_FIXED;
 249                         else
 250                                 *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 251                 }
 252         } else {
 253                 /* Must allocate enough memory for spare+2*sizeof(int) */
 254                 /* for ecc results from device. */
 255                 struct yaffs_NANDSpare nspare;
 256
 257                 memset(&nspare,0,sizeof(nspare));
 258
 259                 retVal =
 260                     dev->readChunkFromNAND(dev, chunkInNAND, data,
 261                                            (yaffs_Spare *) & nspare);
 262                 memcpy(spare, &nspare, sizeof(yaffs_Spare));
 263                 if (data && doErrorCorrection) {
 264                         if (nspare.eccres1 > 0) {
 265                                 T(YAFFS_TRACE_ERROR,
 266                                   (TSTR
 267                                    ("**>>mtd ecc error fix performed on chunk %d:0"
 268                                     TENDSTR), chunkInNAND));
 269                         } else if (nspare.eccres1 < 0) {
 270                                 T(YAFFS_TRACE_ERROR,
 271                                   (TSTR
 272                                    ("**>>mtd ecc error unfixed on chunk %d:0"
 273                                     TENDSTR), chunkInNAND));
 274                         }
 275
 276                         if (nspare.eccres2 > 0) {
 277                                 T(YAFFS_TRACE_ERROR,
 278                                   (TSTR
 279                                    ("**>>mtd ecc error fix performed on chunk %d:1"
 280                                     TENDSTR), chunkInNAND));
 281                         } else if (nspare.eccres2 < 0) {
 282                                 T(YAFFS_TRACE_ERROR,
 283                                   (TSTR
 284                                    ("**>>mtd ecc error unfixed on chunk %d:1"
 285                                     TENDSTR), chunkInNAND));
 286                         }
 287
 288                         if (nspare.eccres1 || nspare.eccres2) {
 289                                 /* We had a data problem on this page */
 290                                 yaffs_HandleReadDataError(dev, chunkInNAND);
 291                         }
 292
 293                         if (nspare.eccres1 < 0 || nspare.eccres2 < 0)
 294                                 *eccResult = YAFFS_ECC_RESULT_UNFIXED;
 295                         else if (nspare.eccres1 > 0 || nspare.eccres2 > 0)
 296                                 *eccResult = YAFFS_ECC_RESULT_FIXED;
 297                         else
 298                                 *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 299
 300                 }
 301         }
 302         return retVal;
 303 }
 304
 305 #ifdef NOTYET
 306 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
 307                                   int chunkInNAND)
 308 {
 309
 310         static int init = 0;
 311         static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
 312         static __u8 data[YAFFS_BYTES_PER_CHUNK];
 313         /* Might as well always allocate the larger size for */
 314         /* dev->useNANDECC == true; */
 315         static __u8 spare[sizeof(struct yaffs_NANDSpare)];
 316
 317         dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare);
 318
 319         if (!init) {
 320                 memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK);
 321                 init = 1;
 322         }
 323
 324         if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK))
 325                 return YAFFS_FAIL;
 326         if (memcmp(cmpbuf, spare, 16))
 327                 return YAFFS_FAIL;
 328
 329         return YAFFS_OK;
 330
 331 }
 332 #endif
 333
 334 /*
 335  * Functions for robustisizing
 336  */
 337
 338 static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
 339 {
 340         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
 341
 342         /* Mark the block for retirement */
 343         yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1;
 344         T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
 345           (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
 346
 347         /* TODO:
 348          * Just do a garbage collection on the affected block
 349          * then retire the block
 350          * NB recursion
 351          */
 352 }
 353
 354 #ifdef NOTYET
 355 static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
 356 {
 357 }
 358
 359 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
 360                                      const __u8 * data,
 361                                      const yaffs_Spare * spare)
 362 {
 363 }
 364
 365 static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
 366                                     const yaffs_Spare * spare)
 367 {
 368 }
 369
 370 static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
 371 {
 372         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
 373
 374         /* Mark the block for retirement */
 375         yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
 376         /* Delete the chunk */
 377         yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
 378 }
 379
 380 static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
 381                                const yaffs_Spare * s0, const yaffs_Spare * s1)
 382 {
 383
 384         if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
 385             s0->tagByte0 != s1->tagByte0 ||
 386             s0->tagByte1 != s1->tagByte1 ||
 387             s0->tagByte2 != s1->tagByte2 ||
 388             s0->tagByte3 != s1->tagByte3 ||
 389             s0->tagByte4 != s1->tagByte4 ||
 390             s0->tagByte5 != s1->tagByte5 ||
 391             s0->tagByte6 != s1->tagByte6 ||
 392             s0->tagByte7 != s1->tagByte7 ||
 393             s0->ecc1[0] != s1->ecc1[0] ||
 394             s0->ecc1[1] != s1->ecc1[1] ||
 395             s0->ecc1[2] != s1->ecc1[2] ||
 396             s0->ecc2[0] != s1->ecc2[0] ||
 397             s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) {
 398                 return 0;
 399         }
 400
 401         return 1;
 402 }
 403 #endif                          /* NOTYET */
 404
 405 int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
 406                                                     int chunkInNAND,
 407                                                     const __u8 * data,
 408                                                     const yaffs_ExtendedTags *
 409                                                     eTags)
 410 {
 411         yaffs_Spare spare;
 412         yaffs_Tags tags;
 413
 414         yaffs_SpareInitialise(&spare);
 415
 416         if (eTags->chunkDeleted) {
 417                 spare.pageStatus = 0;
 418         } else {
 419                 tags.objectId = eTags->objectId;
 420                 tags.chunkId = eTags->chunkId;
 421
 422                 tags.byteCountLSB = eTags->byteCount & 0x3ff;
 423
 424                 if(dev->nDataBytesPerChunk >= 1024){
 425                         tags.byteCountMSB = (eTags->byteCount >> 10) & 3;
 426                 } else {
 427                         tags.byteCountMSB = 3;
 428                 }
 429
 430
 431                 tags.serialNumber = eTags->serialNumber;
 432
 433                 if (!dev->useNANDECC && data) {
 434                         yaffs_CalcECC(data, &spare);
 435                 }
 436                 yaffs_LoadTagsIntoSpare(&spare, &tags);
 437
 438         }
 439
 440         return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
 441 }
 442
 443 int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
 444                                                      int chunkInNAND,
 445                                                      __u8 * data,
 446                                                      yaffs_ExtendedTags * eTags)
 447 {
 448
 449         yaffs_Spare spare;
 450         yaffs_Tags tags;
 451         yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN;
 452
 453         static yaffs_Spare spareFF;
 454         static int init = 0;
 455
 456         if (!init) {
 457                 memset(&spareFF, 0xFF, sizeof(spareFF));
 458                 init = 1;
 459         }
 460
 461         if (yaffs_ReadChunkFromNAND
 462             (dev, chunkInNAND, data, &spare, &eccResult, 1)) {
 463                 /* eTags may be NULL */
 464                 if (eTags) {
 465
 466                         int deleted =
 467                             (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0;
 468
 469                         eTags->chunkDeleted = deleted;
 470                         eTags->eccResult = eccResult;
 471                         eTags->blockBad = 0;    /* We're reading it */
 472                         /* therefore it is not a bad block */
 473                         eTags->chunkUsed =
 474                             (memcmp(&spareFF, &spare, sizeof(spareFF)) !=
 475                              0) ? 1 : 0;
 476
 477                         if (eTags->chunkUsed) {
 478                                 yaffs_GetTagsFromSpare(dev, &spare, &tags);
 479
 480                                 eTags->objectId = tags.objectId;
 481                                 eTags->chunkId = tags.chunkId;
 482                                 eTags->byteCount = tags.byteCountLSB;
 483
 484                                 if(dev->nDataBytesPerChunk >= 1024)
 485                                         eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10);
 486
 487                                 eTags->serialNumber = tags.serialNumber;
 488                         }
 489                 }
 490
 491                 return YAFFS_OK;
 492         } else {
 493                 return YAFFS_FAIL;
 494         }
 495 }
 496
 497 int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
 498                                             int blockInNAND)
 499 {
 500
 501         yaffs_Spare spare;
 502
 503         memset(&spare, 0xff, sizeof(yaffs_Spare));
 504
 505         spare.blockStatus = 'Y';
 506
 507         yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL,
 508                                &spare);
 509         yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1,
 510                                NULL, &spare);
 511
 512         return YAFFS_OK;
 513
 514 }
 515
 516 int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
 517                                           int blockNo,
 518                                           yaffs_BlockState *state,
 519                                           __u32 *sequenceNumber)
 520 {
 521
 522         yaffs_Spare spare0, spare1;
 523         static yaffs_Spare spareFF;
 524         static int init;
 525         yaffs_ECCResult dummy;
 526
 527         if (!init) {
 528                 memset(&spareFF, 0xFF, sizeof(spareFF));
 529                 init = 1;
 530         }
 531
 532         *sequenceNumber = 0;
 533
 534         yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL,
 535                                 &spare0, &dummy, 1);
 536         yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL,
 537                                 &spare1, &dummy, 1);
 538
 539         if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7)
 540                 *state = YAFFS_BLOCK_STATE_DEAD;
 541         else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0)
 542                 *state = YAFFS_BLOCK_STATE_EMPTY;
 543         else
 544                 *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
 545
 546         return YAFFS_OK;
 547 }