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