Add Phils checkpoint configuration
[yaffs2.git] / yaffs_tagscompat.c
1 /*
2  * YAFFS: Yet another FFS. A NAND-flash specific file system. 
3  * yaffs_tagscompat.h: Tags compatability layer to use YAFFS1 formatted NAND.
4  *
5  * Copyright (C) 2002 Aleph One Ltd.
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  * $Id: yaffs_tagscompat.c,v 1.8 2005-11-29 20:54:32 marty Exp $
14  */
15
16 #include "yaffs_guts.h"
17 #include "yaffs_tagscompat.h"
18 #include "yaffs_ecc.h"
19
20 static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
21 #ifdef NOTYET
22 static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
23 static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
24                                      const __u8 * data,
25                                      const yaffs_Spare * spare);
26 static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
27                                     const yaffs_Spare * spare);
28 static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
29 #endif
30
31 static const char yaffs_countBitsTable[256] = {
32         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
33         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
34         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
35         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
36         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
37         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
38         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
39         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
40         1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
41         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
42         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
43         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
44         2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
45         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
46         3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
47         4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
48 };
49
50 static int yaffs_CountBits(__u8 x)
51 {
52         int retVal;
53         retVal = yaffs_countBitsTable[x];
54         return retVal;
55 }
56
57 /********** Tags ECC calculations  *********/
58
59 void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
60 {
61         yaffs_ECCCalculate(data, spare->ecc1);
62         yaffs_ECCCalculate(&data[256], spare->ecc2);
63 }
64
65 void yaffs_CalcTagsECC(yaffs_Tags * tags)
66 {
67         /* Calculate an ecc */
68
69         unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
70         unsigned i, j;
71         unsigned ecc = 0;
72         unsigned bit = 0;
73
74         tags->ecc = 0;
75
76         for (i = 0; i < 8; i++) {
77                 for (j = 1; j & 0xff; j <<= 1) {
78                         bit++;
79                         if (b[i] & j) {
80                                 ecc ^= bit;
81                         }
82                 }
83         }
84
85         tags->ecc = ecc;
86
87 }
88
89 int yaffs_CheckECCOnTags(yaffs_Tags * tags)
90 {
91         unsigned ecc = tags->ecc;
92
93         yaffs_CalcTagsECC(tags);
94
95         ecc ^= tags->ecc;
96
97         if (ecc && ecc <= 64) {
98                 /* TODO: Handle the failure better. Retire? */
99                 unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
100
101                 ecc--;
102
103                 b[ecc / 8] ^= (1 << (ecc & 7));
104
105                 /* Now recvalc the ecc */
106                 yaffs_CalcTagsECC(tags);
107
108                 return 1;       /* recovered error */
109         } else if (ecc) {
110                 /* Wierd ecc failure value */
111                 /* TODO Need to do somethiong here */
112                 return -1;      /* unrecovered error */
113         }
114
115         return 0;
116 }
117
118 /********** Tags **********/
119
120 static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
121                                     yaffs_Tags * tagsPtr)
122 {
123         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
124
125         yaffs_CalcTagsECC(tagsPtr);
126
127         sparePtr->tagByte0 = tu->asBytes[0];
128         sparePtr->tagByte1 = tu->asBytes[1];
129         sparePtr->tagByte2 = tu->asBytes[2];
130         sparePtr->tagByte3 = tu->asBytes[3];
131         sparePtr->tagByte4 = tu->asBytes[4];
132         sparePtr->tagByte5 = tu->asBytes[5];
133         sparePtr->tagByte6 = tu->asBytes[6];
134         sparePtr->tagByte7 = tu->asBytes[7];
135 }
136
137 static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
138                                    yaffs_Tags * tagsPtr)
139 {
140         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
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(tagsPtr);
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_Tags 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.objectId;
470                                 eTags->chunkId = tags.chunkId;
471                                 eTags->byteCount = tags.byteCount;
472                                 eTags->serialNumber = tags.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 }