← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/mtd/nand/nand_ecc.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/mtd/nand/nand_ecc.c
 
1
/*
 
2
 * This file contains an ECC algorithm that detects and corrects 1 bit
 
3
 * errors in a 256 byte block of data.
 
4
 *
 
5
 * drivers/mtd/nand/nand_ecc.c
 
6
 *
 
7
 * Copyright © 2008 Koninklijke Philips Electronics NV.
 
8
 *                  Author: Frans Meulenbroeks
 
9
 *
 
10
 * Completely replaces the previous ECC implementation which was written by:
 
11
 *   Steven J. Hill (sjhill@realitydiluted.com)
 
12
 *   Thomas Gleixner (tglx@linutronix.de)
 
13
 *
 
14
 * Information on how this algorithm works and how it was developed
 
15
 * can be found in Documentation/mtd/nand_ecc.txt
 
16
 *
 
17
 * This file is free software; you can redistribute it and/or modify it
 
18
 * under the terms of the GNU General Public License as published by the
 
19
 * Free Software Foundation; either version 2 or (at your option) any
 
20
 * later version.
 
21
 *
 
22
 * This file is distributed in the hope that it will be useful, but WITHOUT
 
23
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
24
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
25
 * for more details.
 
26
 *
 
27
 * You should have received a copy of the GNU General Public License along
 
28
 * with this file; if not, write to the Free Software Foundation, Inc.,
 
29
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 
30
 *
 
31
 */
 
32
 
 
33
/*
 
34
 * The STANDALONE macro is useful when running the code outside the kernel
 
35
 * e.g. when running the code in a testbed or a benchmark program.
 
36
 * When STANDALONE is used, the module related macros are commented out
 
37
 * as well as the linux include files.
 
38
 * Instead a private definition of mtd_info is given to satisfy the compiler
 
39
 * (the code does not use mtd_info, so the code does not care)
 
40
 */
 
41
#ifndef STANDALONE
 
42
#include <linux/types.h>
 
43
#include <linux/kernel.h>
 
44
#include <linux/module.h>
 
45
#include <linux/mtd/mtd.h>
 
46
#include <linux/mtd/nand.h>
 
47
#include <linux/mtd/nand_ecc.h>
 
48
#include <asm/byteorder.h>
 
49
#else
 
50
#include <stdint.h>
 
51
struct mtd_info;
 
52
#define EXPORT_SYMBOL(x)  /* x */
 
53
 
 
54
#define MODULE_LICENSE(x)       /* x */
 
55
#define MODULE_AUTHOR(x)        /* x */
 
56
#define MODULE_DESCRIPTION(x)   /* x */
 
57
 
 
58
#define printk printf
 
59
#define KERN_ERR                ""
 
60
#endif
 
61
 
 
62
/*
 
63
 * invparity is a 256 byte table that contains the odd parity
 
64
 * for each byte. So if the number of bits in a byte is even,
 
65
 * the array element is 1, and when the number of bits is odd
 
66
 * the array eleemnt is 0.
 
67
 */
 
68
static const char invparity[256] = {
 
69
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
70
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
71
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
72
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
73
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
74
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
75
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
76
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
77
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
78
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
79
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
80
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
81
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
 
82
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
83
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
 
84
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
 
85
};
 
86
 
 
87
/*
 
88
 * bitsperbyte contains the number of bits per byte
 
89
 * this is only used for testing and repairing parity
 
90
 * (a precalculated value slightly improves performance)
 
91
 */
 
92
static const char bitsperbyte[256] = {
 
93
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
 
94
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 
95
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 
96
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
97
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 
98
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
99
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
100
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 
101
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 
102
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
103
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
104
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 
105
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 
106
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 
107
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 
108
        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
 
109
};
 
110
 
 
111
/*
 
112
 * addressbits is a lookup table to filter out the bits from the xor-ed
 
113
 * ECC data that identify the faulty location.
 
114
 * this is only used for repairing parity
 
115
 * see the comments in nand_correct_data for more details
 
116
 */
 
117
static const char addressbits[256] = {
 
118
        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
 
119
        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
 
120
        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
 
121
        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
 
122
        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
 
123
        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
 
124
        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
 
125
        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
 
126
        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
 
127
        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
 
128
        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
 
129
        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
 
130
        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
 
131
        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
 
132
        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
 
133
        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
 
134
        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
 
135
        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
 
136
        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
 
137
        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
 
138
        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
 
139
        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
 
140
        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
 
141
        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
 
142
        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
 
143
        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
 
144
        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
 
145
        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
 
146
        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
 
147
        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
 
148
        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
 
149
        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f
 
150
};
 
151
 
 
152
/**
 
153
 * __nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte
 
154
 *                       block
 
155
 * @buf:        input buffer with raw data
 
156
 * @eccsize:    data bytes per ECC step (256 or 512)
 
157
 * @code:       output buffer with ECC
 
158
 */
 
159
void __nand_calculate_ecc(const unsigned char *buf, unsigned int eccsize,
 
160
                       unsigned char *code)
 
161
{
 
162
        int i;
 
163
        const uint32_t *bp = (uint32_t *)buf;
 
164
        /* 256 or 512 bytes/ecc  */
 
165
        const uint32_t eccsize_mult = eccsize >> 8;
 
166
        uint32_t cur;           /* current value in buffer */
 
167
        /* rp0..rp15..rp17 are the various accumulated parities (per byte) */
 
168
        uint32_t rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7;
 
169
        uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15, rp16;
 
170
        uint32_t uninitialized_var(rp17);       /* to make compiler happy */
 
171
        uint32_t par;           /* the cumulative parity for all data */
 
172
        uint32_t tmppar;        /* the cumulative parity for this iteration;
 
173
                                   for rp12, rp14 and rp16 at the end of the
 
174
                                   loop */
 
175
 
 
176
        par = 0;
 
177
        rp4 = 0;
 
178
        rp6 = 0;
 
179
        rp8 = 0;
 
180
        rp10 = 0;
 
181
        rp12 = 0;
 
182
        rp14 = 0;
 
183
        rp16 = 0;
 
184
 
 
185
        /*
 
186
         * The loop is unrolled a number of times;
 
187
         * This avoids if statements to decide on which rp value to update
 
188
         * Also we process the data by longwords.
 
189
         * Note: passing unaligned data might give a performance penalty.
 
190
         * It is assumed that the buffers are aligned.
 
191
         * tmppar is the cumulative sum of this iteration.
 
192
         * needed for calculating rp12, rp14, rp16 and par
 
193
         * also used as a performance improvement for rp6, rp8 and rp10
 
194
         */
 
195
        for (i = 0; i < eccsize_mult << 2; i++) {
 
196
                cur = *bp++;
 
197
                tmppar = cur;
 
198
                rp4 ^= cur;
 
199
                cur = *bp++;
 
200
                tmppar ^= cur;
 
201
                rp6 ^= tmppar;
 
202
                cur = *bp++;
 
203
                tmppar ^= cur;
 
204
                rp4 ^= cur;
 
205
                cur = *bp++;
 
206
                tmppar ^= cur;
 
207
                rp8 ^= tmppar;
 
208
 
 
209
                cur = *bp++;
 
210
                tmppar ^= cur;
 
211
                rp4 ^= cur;
 
212
                rp6 ^= cur;
 
213
                cur = *bp++;
 
214
                tmppar ^= cur;
 
215
                rp6 ^= cur;
 
216
                cur = *bp++;
 
217
                tmppar ^= cur;
 
218
                rp4 ^= cur;
 
219
                cur = *bp++;
 
220
                tmppar ^= cur;
 
221
                rp10 ^= tmppar;
 
222
 
 
223
                cur = *bp++;
 
224
                tmppar ^= cur;
 
225
                rp4 ^= cur;
 
226
                rp6 ^= cur;
 
227
                rp8 ^= cur;
 
228
                cur = *bp++;
 
229
                tmppar ^= cur;
 
230
                rp6 ^= cur;
 
231
                rp8 ^= cur;
 
232
                cur = *bp++;
 
233
                tmppar ^= cur;
 
234
                rp4 ^= cur;
 
235
                rp8 ^= cur;
 
236
                cur = *bp++;
 
237
                tmppar ^= cur;
 
238
                rp8 ^= cur;
 
239
 
 
240
                cur = *bp++;
 
241
                tmppar ^= cur;
 
242
                rp4 ^= cur;
 
243
                rp6 ^= cur;
 
244
                cur = *bp++;
 
245
                tmppar ^= cur;
 
246
                rp6 ^= cur;
 
247
                cur = *bp++;
 
248
                tmppar ^= cur;
 
249
                rp4 ^= cur;
 
250
                cur = *bp++;
 
251
                tmppar ^= cur;
 
252
 
 
253
                par ^= tmppar;
 
254
                if ((i & 0x1) == 0)
 
255
                        rp12 ^= tmppar;
 
256
                if ((i & 0x2) == 0)
 
257
                        rp14 ^= tmppar;
 
258
                if (eccsize_mult == 2 && (i & 0x4) == 0)
 
259
                        rp16 ^= tmppar;
 
260
        }
 
261
 
 
262
        /*
 
263
         * handle the fact that we use longword operations
 
264
         * we'll bring rp4..rp14..rp16 back to single byte entities by
 
265
         * shifting and xoring first fold the upper and lower 16 bits,
 
266
         * then the upper and lower 8 bits.
 
267
         */
 
268
        rp4 ^= (rp4 >> 16);
 
269
        rp4 ^= (rp4 >> 8);
 
270
        rp4 &= 0xff;
 
271
        rp6 ^= (rp6 >> 16);
 
272
        rp6 ^= (rp6 >> 8);
 
273
        rp6 &= 0xff;
 
274
        rp8 ^= (rp8 >> 16);
 
275
        rp8 ^= (rp8 >> 8);
 
276
        rp8 &= 0xff;
 
277
        rp10 ^= (rp10 >> 16);
 
278
        rp10 ^= (rp10 >> 8);
 
279
        rp10 &= 0xff;
 
280
        rp12 ^= (rp12 >> 16);
 
281
        rp12 ^= (rp12 >> 8);
 
282
        rp12 &= 0xff;
 
283
        rp14 ^= (rp14 >> 16);
 
284
        rp14 ^= (rp14 >> 8);
 
285
        rp14 &= 0xff;
 
286
        if (eccsize_mult == 2) {
 
287
                rp16 ^= (rp16 >> 16);
 
288
                rp16 ^= (rp16 >> 8);
 
289
                rp16 &= 0xff;
 
290
        }
 
291
 
 
292
        /*
 
293
         * we also need to calculate the row parity for rp0..rp3
 
294
         * This is present in par, because par is now
 
295
         * rp3 rp3 rp2 rp2 in little endian and
 
296
         * rp2 rp2 rp3 rp3 in big endian
 
297
         * as well as
 
298
         * rp1 rp0 rp1 rp0 in little endian and
 
299
         * rp0 rp1 rp0 rp1 in big endian
 
300
         * First calculate rp2 and rp3
 
301
         */
 
302
#ifdef __BIG_ENDIAN
 
303
        rp2 = (par >> 16);
 
304
        rp2 ^= (rp2 >> 8);
 
305
        rp2 &= 0xff;
 
306
        rp3 = par & 0xffff;
 
307
        rp3 ^= (rp3 >> 8);
 
308
        rp3 &= 0xff;
 
309
#else
 
310
        rp3 = (par >> 16);
 
311
        rp3 ^= (rp3 >> 8);
 
312
        rp3 &= 0xff;
 
313
        rp2 = par & 0xffff;
 
314
        rp2 ^= (rp2 >> 8);
 
315
        rp2 &= 0xff;
 
316
#endif
 
317
 
 
318
        /* reduce par to 16 bits then calculate rp1 and rp0 */
 
319
        par ^= (par >> 16);
 
320
#ifdef __BIG_ENDIAN
 
321
        rp0 = (par >> 8) & 0xff;
 
322
        rp1 = (par & 0xff);
 
323
#else
 
324
        rp1 = (par >> 8) & 0xff;
 
325
        rp0 = (par & 0xff);
 
326
#endif
 
327
 
 
328
        /* finally reduce par to 8 bits */
 
329
        par ^= (par >> 8);
 
330
        par &= 0xff;
 
331
 
 
332
        /*
 
333
         * and calculate rp5..rp15..rp17
 
334
         * note that par = rp4 ^ rp5 and due to the commutative property
 
335
         * of the ^ operator we can say:
 
336
         * rp5 = (par ^ rp4);
 
337
         * The & 0xff seems superfluous, but benchmarking learned that
 
338
         * leaving it out gives slightly worse results. No idea why, probably
 
339
         * it has to do with the way the pipeline in pentium is organized.
 
340
         */
 
341
        rp5 = (par ^ rp4) & 0xff;
 
342
        rp7 = (par ^ rp6) & 0xff;
 
343
        rp9 = (par ^ rp8) & 0xff;
 
344
        rp11 = (par ^ rp10) & 0xff;
 
345
        rp13 = (par ^ rp12) & 0xff;
 
346
        rp15 = (par ^ rp14) & 0xff;
 
347
        if (eccsize_mult == 2)
 
348
                rp17 = (par ^ rp16) & 0xff;
 
349
 
 
350
        /*
 
351
         * Finally calculate the ECC bits.
 
352
         * Again here it might seem that there are performance optimisations
 
353
         * possible, but benchmarks showed that on the system this is developed
 
354
         * the code below is the fastest
 
355
         */
 
356
#ifdef CONFIG_MTD_NAND_ECC_SMC
 
357
        code[0] =
 
358
            (invparity[rp7] << 7) |
 
359
            (invparity[rp6] << 6) |
 
360
            (invparity[rp5] << 5) |
 
361
            (invparity[rp4] << 4) |
 
362
            (invparity[rp3] << 3) |
 
363
            (invparity[rp2] << 2) |
 
364
            (invparity[rp1] << 1) |
 
365
            (invparity[rp0]);
 
366
        code[1] =
 
367
            (invparity[rp15] << 7) |
 
368
            (invparity[rp14] << 6) |
 
369
            (invparity[rp13] << 5) |
 
370
            (invparity[rp12] << 4) |
 
371
            (invparity[rp11] << 3) |
 
372
            (invparity[rp10] << 2) |
 
373
            (invparity[rp9] << 1)  |
 
374
            (invparity[rp8]);
 
375
#else
 
376
        code[1] =
 
377
            (invparity[rp7] << 7) |
 
378
            (invparity[rp6] << 6) |
 
379
            (invparity[rp5] << 5) |
 
380
            (invparity[rp4] << 4) |
 
381
            (invparity[rp3] << 3) |
 
382
            (invparity[rp2] << 2) |
 
383
            (invparity[rp1] << 1) |
 
384
            (invparity[rp0]);
 
385
        code[0] =
 
386
            (invparity[rp15] << 7) |
 
387
            (invparity[rp14] << 6) |
 
388
            (invparity[rp13] << 5) |
 
389
            (invparity[rp12] << 4) |
 
390
            (invparity[rp11] << 3) |
 
391
            (invparity[rp10] << 2) |
 
392
            (invparity[rp9] << 1)  |
 
393
            (invparity[rp8]);
 
394
#endif
 
395
        if (eccsize_mult == 1)
 
396
                code[2] =
 
397
                    (invparity[par & 0xf0] << 7) |
 
398
                    (invparity[par & 0x0f] << 6) |
 
399
                    (invparity[par & 0xcc] << 5) |
 
400
                    (invparity[par & 0x33] << 4) |
 
401
                    (invparity[par & 0xaa] << 3) |
 
402
                    (invparity[par & 0x55] << 2) |
 
403
                    3;
 
404
        else
 
405
                code[2] =
 
406
                    (invparity[par & 0xf0] << 7) |
 
407
                    (invparity[par & 0x0f] << 6) |
 
408
                    (invparity[par & 0xcc] << 5) |
 
409
                    (invparity[par & 0x33] << 4) |
 
410
                    (invparity[par & 0xaa] << 3) |
 
411
                    (invparity[par & 0x55] << 2) |
 
412
                    (invparity[rp17] << 1) |
 
413
                    (invparity[rp16] << 0);
 
414
}
 
415
EXPORT_SYMBOL(__nand_calculate_ecc);
 
416
 
 
417
/**
 
418
 * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte
 
419
 *                       block
 
420
 * @mtd:        MTD block structure
 
421
 * @buf:        input buffer with raw data
 
422
 * @code:       output buffer with ECC
 
423
 */
 
424
int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
 
425
                       unsigned char *code)
 
426
{
 
427
        __nand_calculate_ecc(buf,
 
428
                        ((struct nand_chip *)mtd->priv)->ecc.size, code);
 
429
 
 
430
        return 0;
 
431
}
 
432
EXPORT_SYMBOL(nand_calculate_ecc);
 
433
 
 
434
/**
 
435
 * __nand_correct_data - [NAND Interface] Detect and correct bit error(s)
 
436
 * @buf:        raw data read from the chip
 
437
 * @read_ecc:   ECC from the chip
 
438
 * @calc_ecc:   the ECC calculated from raw data
 
439
 * @eccsize:    data bytes per ECC step (256 or 512)
 
440
 *
 
441
 * Detect and correct a 1 bit error for eccsize byte block
 
442
 */
 
443
int __nand_correct_data(unsigned char *buf,
 
444
                        unsigned char *read_ecc, unsigned char *calc_ecc,
 
445
                        unsigned int eccsize)
 
446
{
 
447
        unsigned char b0, b1, b2, bit_addr;
 
448
        unsigned int byte_addr;
 
449
        /* 256 or 512 bytes/ecc  */
 
450
        const uint32_t eccsize_mult = eccsize >> 8;
 
451
 
 
452
        /*
 
453
         * b0 to b2 indicate which bit is faulty (if any)
 
454
         * we might need the xor result  more than once,
 
455
         * so keep them in a local var
 
456
        */
 
457
#ifdef CONFIG_MTD_NAND_ECC_SMC
 
458
        b0 = read_ecc[0] ^ calc_ecc[0];
 
459
        b1 = read_ecc[1] ^ calc_ecc[1];
 
460
#else
 
461
        b0 = read_ecc[1] ^ calc_ecc[1];
 
462
        b1 = read_ecc[0] ^ calc_ecc[0];
 
463
#endif
 
464
        b2 = read_ecc[2] ^ calc_ecc[2];
 
465
 
 
466
        /* check if there are any bitfaults */
 
467
 
 
468
        /* repeated if statements are slightly more efficient than switch ... */
 
469
        /* ordered in order of likelihood */
 
470
 
 
471
        if ((b0 | b1 | b2) == 0)
 
472
                return 0;       /* no error */
 
473
 
 
474
        if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) &&
 
475
            (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) &&
 
476
            ((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) ||
 
477
             (eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) {
 
478
        /* single bit error */
 
479
                /*
 
480
                 * rp17/rp15/13/11/9/7/5/3/1 indicate which byte is the faulty
 
481
                 * byte, cp 5/3/1 indicate the faulty bit.
 
482
                 * A lookup table (called addressbits) is used to filter
 
483
                 * the bits from the byte they are in.
 
484
                 * A marginal optimisation is possible by having three
 
485
                 * different lookup tables.
 
486
                 * One as we have now (for b0), one for b2
 
487
                 * (that would avoid the >> 1), and one for b1 (with all values
 
488
                 * << 4). However it was felt that introducing two more tables
 
489
                 * hardly justify the gain.
 
490
                 *
 
491
                 * The b2 shift is there to get rid of the lowest two bits.
 
492
                 * We could also do addressbits[b2] >> 1 but for the
 
493
                 * performance it does not make any difference
 
494
                 */
 
495
                if (eccsize_mult == 1)
 
496
                        byte_addr = (addressbits[b1] << 4) + addressbits[b0];
 
497
                else
 
498
                        byte_addr = (addressbits[b2 & 0x3] << 8) +
 
499
                                    (addressbits[b1] << 4) + addressbits[b0];
 
500
                bit_addr = addressbits[b2 >> 2];
 
501
                /* flip the bit */
 
502
                buf[byte_addr] ^= (1 << bit_addr);
 
503
                return 1;
 
504
 
 
505
        }
 
506
        /* count nr of bits; use table lookup, faster than calculating it */
 
507
        if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1)
 
508
                return 1;       /* error in ECC data; no action needed */
 
509
 
 
510
        printk(KERN_ERR "uncorrectable error : ");
 
511
        return -1;
 
512
}
 
513
EXPORT_SYMBOL(__nand_correct_data);
 
514
 
 
515
/**
 
516
 * nand_correct_data - [NAND Interface] Detect and correct bit error(s)
 
517
 * @mtd:        MTD block structure
 
518
 * @buf:        raw data read from the chip
 
519
 * @read_ecc:   ECC from the chip
 
520
 * @calc_ecc:   the ECC calculated from raw data
 
521
 *
 
522
 * Detect and correct a 1 bit error for 256/512 byte block
 
523
 */
 
524
int nand_correct_data(struct mtd_info *mtd, unsigned char *buf,
 
525
                      unsigned char *read_ecc, unsigned char *calc_ecc)
 
526
{
 
527
        return __nand_correct_data(buf, read_ecc, calc_ecc,
 
528
                                   ((struct nand_chip *)mtd->priv)->ecc.size);
 
529
}
 
530
EXPORT_SYMBOL(nand_correct_data);
 
531
 
 
532
MODULE_LICENSE("GPL");
 
533
MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>");
 
534
MODULE_DESCRIPTION("Generic NAND ECC support");