Update free chunk count for skipped chunks
[yaffs2.git] / 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 }