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