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_Tags * tagsPtr) 140 { 141 yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; 142 int result; 143 144 tu->asBytes[0] = sparePtr->tagByte0; 145 tu->asBytes[1] = sparePtr->tagByte1; 146 tu->asBytes[2] = sparePtr->tagByte2; 147 tu->asBytes[3] = sparePtr->tagByte3; 148 tu->asBytes[4] = sparePtr->tagByte4; 149 tu->asBytes[5] = sparePtr->tagByte5; 150 tu->asBytes[6] = sparePtr->tagByte6; 151 tu->asBytes[7] = sparePtr->tagByte7; 152 153 result = yaffs_CheckECCOnTags(tagsPtr); 154 if (result > 0) { 155 dev->tagsEccFixed++; 156 } else if (result < 0) { 157 dev->tagsEccUnfixed++; 158 } 159 } 160 161 static void yaffs_SpareInitialise(yaffs_Spare * spare) 162 { 163 memset(spare, 0xFF, sizeof(yaffs_Spare)); 164 } 165 166 static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev, 167 int chunkInNAND, const __u8 * data, 168 yaffs_Spare * spare) 169 { 170 if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) { 171 T(YAFFS_TRACE_ERROR, 172 (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), 173 chunkInNAND)); 174 return YAFFS_FAIL; 175 } 176 177 dev->nPageWrites++; 178 return dev->writeChunkToNAND(dev, chunkInNAND, data, spare); 179 } 180 181 static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, 182 int chunkInNAND, 183 __u8 * data, 184 yaffs_Spare * spare, 185 yaffs_ECCResult * eccResult, 186 int doErrorCorrection) 187 { 188 int retVal; 189 yaffs_Spare localSpare; 190 191 dev->nPageReads++; 192 193 if (!spare && data) { 194 /* If we don't have a real spare, then we use a local one. */ 195 /* Need this for the calculation of the ecc */ 196 spare = &localSpare; 197 } 198 199 if (!dev->useNANDECC) { 200 retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare); 201 if (data && doErrorCorrection) { 202 /* Do ECC correction */ 203 /* Todo handle any errors */ 204 int eccResult1, eccResult2; 205 __u8 calcEcc[3]; 206 207 yaffs_ECCCalculate(data, calcEcc); 208 eccResult1 = 209 yaffs_ECCCorrect(data, spare->ecc1, calcEcc); 210 yaffs_ECCCalculate(&data[256], calcEcc); 211 eccResult2 = 212 yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc); 213 214 if (eccResult1 > 0) { 215 T(YAFFS_TRACE_ERROR, 216 (TSTR 217 ("**>>yaffs ecc error fix performed on chunk %d:0" 218 TENDSTR), chunkInNAND)); 219 dev->eccFixed++; 220 } else if (eccResult1 < 0) { 221 T(YAFFS_TRACE_ERROR, 222 (TSTR 223 ("**>>yaffs ecc error unfixed on chunk %d:0" 224 TENDSTR), chunkInNAND)); 225 dev->eccUnfixed++; 226 } 227 228 if (eccResult2 > 0) { 229 T(YAFFS_TRACE_ERROR, 230 (TSTR 231 ("**>>yaffs ecc error fix performed on chunk %d:1" 232 TENDSTR), chunkInNAND)); 233 dev->eccFixed++; 234 } else if (eccResult2 < 0) { 235 T(YAFFS_TRACE_ERROR, 236 (TSTR 237 ("**>>yaffs ecc error unfixed on chunk %d:1" 238 TENDSTR), chunkInNAND)); 239 dev->eccUnfixed++; 240 } 241 242 if (eccResult1 || eccResult2) { 243 /* We had a data problem on this page */ 244 yaffs_HandleReadDataError(dev, chunkInNAND); 245 } 246 247 if (eccResult1 < 0 || eccResult2 < 0) 248 *eccResult = YAFFS_ECC_RESULT_UNFIXED; 249 else if (eccResult1 > 0 || eccResult2 > 0) 250 *eccResult = YAFFS_ECC_RESULT_FIXED; 251 else 252 *eccResult = YAFFS_ECC_RESULT_NO_ERROR; 253 } 254 } else { 255 /* Must allocate enough memory for spare+2*sizeof(int) */ 256 /* for ecc results from device. */ 257 struct yaffs_NANDSpare nspare; 258 retVal = 259 dev->readChunkFromNAND(dev, chunkInNAND, data, 260 (yaffs_Spare *) & nspare); 261 memcpy(spare, &nspare, sizeof(yaffs_Spare)); 262 if (data && doErrorCorrection) { 263 if (nspare.eccres1 > 0) { 264 T(YAFFS_TRACE_ERROR, 265 (TSTR 266 ("**>>mtd ecc error fix performed on chunk %d:0" 267 TENDSTR), chunkInNAND)); 268 } else if (nspare.eccres1 < 0) { 269 T(YAFFS_TRACE_ERROR, 270 (TSTR 271 ("**>>mtd ecc error unfixed on chunk %d:0" 272 TENDSTR), chunkInNAND)); 273 } 274 275 if (nspare.eccres2 > 0) { 276 T(YAFFS_TRACE_ERROR, 277 (TSTR 278 ("**>>mtd ecc error fix performed on chunk %d:1" 279 TENDSTR), chunkInNAND)); 280 } else if (nspare.eccres2 < 0) { 281 T(YAFFS_TRACE_ERROR, 282 (TSTR 283 ("**>>mtd ecc error unfixed on chunk %d:1" 284 TENDSTR), chunkInNAND)); 285 } 286 287 if (nspare.eccres1 || nspare.eccres2) { 288 /* We had a data problem on this page */ 289 yaffs_HandleReadDataError(dev, chunkInNAND); 290 } 291 292 if (nspare.eccres1 < 0 || nspare.eccres2 < 0) 293 *eccResult = YAFFS_ECC_RESULT_UNFIXED; 294 else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) 295 *eccResult = YAFFS_ECC_RESULT_FIXED; 296 else 297 *eccResult = YAFFS_ECC_RESULT_NO_ERROR; 298 299 } 300 } 301 return retVal; 302 } 303 304 #ifdef NOTYET 305 static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, 306 int chunkInNAND) 307 { 308 309 static int init = 0; 310 static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; 311 static __u8 data[YAFFS_BYTES_PER_CHUNK]; 312 /* Might as well always allocate the larger size for */ 313 /* dev->useNANDECC == true; */ 314 static __u8 spare[sizeof(struct yaffs_NANDSpare)]; 315 316 dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); 317 318 if (!init) { 319 memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); 320 init = 1; 321 } 322 323 if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK)) 324 return YAFFS_FAIL; 325 if (memcmp(cmpbuf, spare, 16)) 326 return YAFFS_FAIL; 327 328 return YAFFS_OK; 329 330 } 331 #endif 332 333 /* 334 * Functions for robustisizing 335 */ 336 337 static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND) 338 { 339 int blockInNAND = chunkInNAND / dev->nChunksPerBlock; 340 341 /* Mark the block for retirement */ 342 yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; 343 T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, 344 (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); 345 346 /* TODO: 347 * Just do a garbage collection on the affected block 348 * then retire the block 349 * NB recursion 350 */ 351 } 352 353 #ifdef NOTYET 354 static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND) 355 { 356 } 357 358 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND, 359 const __u8 * data, 360 const yaffs_Spare * spare) 361 { 362 } 363 364 static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND, 365 const yaffs_Spare * spare) 366 { 367 } 368 369 static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND) 370 { 371 int blockInNAND = chunkInNAND / dev->nChunksPerBlock; 372 373 /* Mark the block for retirement */ 374 yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; 375 /* Delete the chunk */ 376 yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); 377 } 378 379 static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1, 380 const yaffs_Spare * s0, const yaffs_Spare * s1) 381 { 382 383 if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || 384 s0->tagByte0 != s1->tagByte0 || 385 s0->tagByte1 != s1->tagByte1 || 386 s0->tagByte2 != s1->tagByte2 || 387 s0->tagByte3 != s1->tagByte3 || 388 s0->tagByte4 != s1->tagByte4 || 389 s0->tagByte5 != s1->tagByte5 || 390 s0->tagByte6 != s1->tagByte6 || 391 s0->tagByte7 != s1->tagByte7 || 392 s0->ecc1[0] != s1->ecc1[0] || 393 s0->ecc1[1] != s1->ecc1[1] || 394 s0->ecc1[2] != s1->ecc1[2] || 395 s0->ecc2[0] != s1->ecc2[0] || 396 s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) { 397 return 0; 398 } 399 400 return 1; 401 } 402 #endif /* NOTYET */ 403 404 int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev, 405 int chunkInNAND, 406 const __u8 * data, 407 const yaffs_ExtendedTags * 408 eTags) 409 { 410 yaffs_Spare spare; 411 yaffs_Tags tags; 412 413 yaffs_SpareInitialise(&spare); 414 415 if (eTags->chunkDeleted) { 416 spare.pageStatus = 0; 417 } else { 418 tags.objectId = eTags->objectId; 419 tags.chunkId = eTags->chunkId; 420 tags.byteCount = eTags->byteCount; 421 tags.serialNumber = eTags->serialNumber; 422 423 if (!dev->useNANDECC && data) { 424 yaffs_CalcECC(data, &spare); 425 } 426 yaffs_LoadTagsIntoSpare(&spare, &tags); 427 428 } 429 430 return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare); 431 } 432 433 int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev, 434 int chunkInNAND, 435 __u8 * data, 436 yaffs_ExtendedTags * eTags) 437 { 438 439 yaffs_Spare spare; 440 yaffs_Tags tags; 441 yaffs_ECCResult eccResult; 442 443 static yaffs_Spare spareFF; 444 static int init; 445 446 if (!init) { 447 memset(&spareFF, 0xFF, sizeof(spareFF)); 448 init = 1; 449 } 450 451 if (yaffs_ReadChunkFromNAND 452 (dev, chunkInNAND, data, &spare, &eccResult, 1)) { 453 /* eTags may be NULL */ 454 if (eTags) { 455 456 int deleted = 457 (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0; 458 459 eTags->chunkDeleted = deleted; 460 eTags->eccResult = eccResult; 461 eTags->blockBad = 0; /* We're reading it */ 462 /* therefore it is not a bad block */ 463 eTags->chunkUsed = 464 (memcmp(&spareFF, &spare, sizeof(spareFF)) != 465 0) ? 1 : 0; 466 467 if (eTags->chunkUsed) { 468 yaffs_GetTagsFromSpare(dev, &spare, &tags); 469 470 eTags->objectId = tags.objectId; 471 eTags->chunkId = tags.chunkId; 472 eTags->byteCount = tags.byteCount; 473 eTags->serialNumber = tags.serialNumber; 474 } 475 } 476 477 return YAFFS_OK; 478 } else { 479 return YAFFS_FAIL; 480 } 481 } 482 483 int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, 484 int blockInNAND) 485 { 486 487 yaffs_Spare spare; 488 489 memset(&spare, 0xff, sizeof(yaffs_Spare)); 490 491 spare.blockStatus = 'Y'; 492 493 yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL, 494 &spare); 495 yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1, 496 NULL, &spare); 497 498 return YAFFS_OK; 499 500 } 501 502 int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, 503 int blockNo, yaffs_BlockState * 504 state, 505 int *sequenceNumber) 506 { 507 508 yaffs_Spare spare0, spare1; 509 static yaffs_Spare spareFF; 510 static int init; 511 yaffs_ECCResult dummy; 512 513 if (!init) { 514 memset(&spareFF, 0xFF, sizeof(spareFF)); 515 init = 1; 516 } 517 518 *sequenceNumber = 0; 519 520 yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL, 521 &spare0, &dummy, 1); 522 yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL, 523 &spare1, &dummy, 1); 524 525 if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) 526 *state = YAFFS_BLOCK_STATE_DEAD; 527 else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) 528 *state = YAFFS_BLOCK_STATE_EMPTY; 529 else 530 *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; 531 532 return YAFFS_OK; 533 } 534