2 * This file contains an ECC algorithm that detects and corrects 1 bit
3 * errors in a 256 byte block of data.
5 * drivers/mtd/nand/nand_ecc.c
7 * Copyright © 2008 Koninklijke Philips Electronics NV.
8 * Author: Frans Meulenbroeks
10 * Completely replaces the previous ECC implementation which was written by:
11 * Steven J. Hill (sjhill@realitydiluted.com)
12 * Thomas Gleixner (tglx@linutronix.de)
14 * Information on how this algorithm works and how it was developed
15 * can be found in Documentation/mtd/nand_ecc.txt
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
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
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.
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)
42 #include <linux/types.h>
43 #include <linux/kernel.h>
44 #include <linux/module.h>
45 #include <linux/mtd/nand_ecc.h>
46 #include <asm/byteorder.h>
50 #define EXPORT_SYMBOL(x) /* x */
52 #define MODULE_LICENSE(x) /* x */
53 #define MODULE_AUTHOR(x) /* x */
54 #define MODULE_DESCRIPTION(x) /* x */
61 * invparity is a 256 byte table that contains the odd parity
62 * for each byte. So if the number of bits in a byte is even,
63 * the array element is 1, and when the number of bits is odd
64 * the array eleemnt is 0.
66 static const char invparity[256] = {
67 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
68 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
69 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
70 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
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 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
74 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
75 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
76 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
77 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
78 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
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 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
82 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
86 * bitsperbyte contains the number of bits per byte
87 * this is only used for testing and repairing parity
88 * (a precalculated value slightly improves performance)
90 static const char bitsperbyte[256] = {
91 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
92 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
93 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
94 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
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 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
98 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
99 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
100 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
101 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
102 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
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 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
106 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
110 * addressbits is a lookup table to filter out the bits from the xor-ed
111 * ecc data that identify the faulty location.
112 * this is only used for repairing parity
113 * see the comments in nand_correct_data for more details
115 static const char addressbits[256] = {
116 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
117 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
118 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
119 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
120 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
121 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
122 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
123 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
124 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
125 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
126 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
127 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
128 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
129 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
130 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
131 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
132 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
133 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
134 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
135 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
136 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
137 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
138 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
139 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
140 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
141 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
142 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
143 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
144 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
145 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
146 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
147 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f
151 * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256-byte block
152 * @mtd: MTD block structure (unused)
153 * @buf: input buffer with raw data
154 * @code: output buffer with ECC
156 int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
160 const uint32_t *bp = (uint32_t *)buf;
161 uint32_t cur; /* current value in buffer */
162 /* rp0..rp15 are the various accumulated parities (per byte) */
163 uint32_t rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7;
164 uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15;
165 uint32_t par; /* the cumulative parity for all data */
166 uint32_t tmppar; /* the cumulative parity for this iteration;
167 for rp12 and rp14 at the end of the loop */
178 * The loop is unrolled a number of times;
179 * This avoids if statements to decide on which rp value to update
180 * Also we process the data by longwords.
181 * Note: passing unaligned data might give a performance penalty.
182 * It is assumed that the buffers are aligned.
183 * tmppar is the cumulative sum of this iteration.
184 * needed for calculating rp12, rp14 and par
185 * also used as a performance improvement for rp6, rp8 and rp10
187 for (i = 0; i < 4; i++) {
253 * handle the fact that we use longword operations
254 * we'll bring rp4..rp14 back to single byte entities by shifting and
255 * xoring first fold the upper and lower 16 bits,
256 * then the upper and lower 8 bits.
267 rp10 ^= (rp10 >> 16);
270 rp12 ^= (rp12 >> 16);
273 rp14 ^= (rp14 >> 16);
278 * we also need to calculate the row parity for rp0..rp3
279 * This is present in par, because par is now
280 * rp3 rp3 rp2 rp2 in little endian and
281 * rp2 rp2 rp3 rp3 in big endian
283 * rp1 rp0 rp1 rp0 in little endian and
284 * rp0 rp1 rp0 rp1 in big endian
285 * First calculate rp2 and rp3
303 /* reduce par to 16 bits then calculate rp1 and rp0 */
306 rp0 = (par >> 8) & 0xff;
309 rp1 = (par >> 8) & 0xff;
313 /* finally reduce par to 8 bits */
318 * and calculate rp5..rp15
319 * note that par = rp4 ^ rp5 and due to the commutative property
320 * of the ^ operator we can say:
322 * The & 0xff seems superfluous, but benchmarking learned that
323 * leaving it out gives slightly worse results. No idea why, probably
324 * it has to do with the way the pipeline in pentium is organized.
326 rp5 = (par ^ rp4) & 0xff;
327 rp7 = (par ^ rp6) & 0xff;
328 rp9 = (par ^ rp8) & 0xff;
329 rp11 = (par ^ rp10) & 0xff;
330 rp13 = (par ^ rp12) & 0xff;
331 rp15 = (par ^ rp14) & 0xff;
334 * Finally calculate the ecc bits.
335 * Again here it might seem that there are performance optimisations
336 * possible, but benchmarks showed that on the system this is developed
337 * the code below is the fastest
339 #ifdef CONFIG_MTD_NAND_ECC_SMC
341 (invparity[rp7] << 7) |
342 (invparity[rp6] << 6) |
343 (invparity[rp5] << 5) |
344 (invparity[rp4] << 4) |
345 (invparity[rp3] << 3) |
346 (invparity[rp2] << 2) |
347 (invparity[rp1] << 1) |
350 (invparity[rp15] << 7) |
351 (invparity[rp14] << 6) |
352 (invparity[rp13] << 5) |
353 (invparity[rp12] << 4) |
354 (invparity[rp11] << 3) |
355 (invparity[rp10] << 2) |
356 (invparity[rp9] << 1) |
360 (invparity[rp7] << 7) |
361 (invparity[rp6] << 6) |
362 (invparity[rp5] << 5) |
363 (invparity[rp4] << 4) |
364 (invparity[rp3] << 3) |
365 (invparity[rp2] << 2) |
366 (invparity[rp1] << 1) |
369 (invparity[rp15] << 7) |
370 (invparity[rp14] << 6) |
371 (invparity[rp13] << 5) |
372 (invparity[rp12] << 4) |
373 (invparity[rp11] << 3) |
374 (invparity[rp10] << 2) |
375 (invparity[rp9] << 1) |
379 (invparity[par & 0xf0] << 7) |
380 (invparity[par & 0x0f] << 6) |
381 (invparity[par & 0xcc] << 5) |
382 (invparity[par & 0x33] << 4) |
383 (invparity[par & 0xaa] << 3) |
384 (invparity[par & 0x55] << 2) |
388 EXPORT_SYMBOL(nand_calculate_ecc);
391 * nand_correct_data - [NAND Interface] Detect and correct bit error(s)
392 * @mtd: MTD block structure (unused)
393 * @buf: raw data read from the chip
394 * @read_ecc: ECC from the chip
395 * @calc_ecc: the ECC calculated from raw data
397 * Detect and correct a 1 bit error for 256 byte block
399 int nand_correct_data(struct mtd_info *mtd, unsigned char *buf,
400 unsigned char *read_ecc, unsigned char *calc_ecc)
402 unsigned char b0, b1, b2;
403 unsigned char byte_addr, bit_addr;
406 * b0 to b2 indicate which bit is faulty (if any)
407 * we might need the xor result more than once,
408 * so keep them in a local var
410 #ifdef CONFIG_MTD_NAND_ECC_SMC
411 b0 = read_ecc[0] ^ calc_ecc[0];
412 b1 = read_ecc[1] ^ calc_ecc[1];
414 b0 = read_ecc[1] ^ calc_ecc[1];
415 b1 = read_ecc[0] ^ calc_ecc[0];
417 b2 = read_ecc[2] ^ calc_ecc[2];
419 /* check if there are any bitfaults */
421 /* repeated if statements are slightly more efficient than switch ... */
422 /* ordered in order of likelihood */
424 if ((b0 | b1 | b2) == 0)
425 return 0; /* no error */
427 if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) &&
428 (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) &&
429 (((b2 ^ (b2 >> 1)) & 0x54) == 0x54)) { /* single bit error */
431 * rp15/13/11/9/7/5/3/1 indicate which byte is the faulty byte
432 * cp 5/3/1 indicate the faulty bit.
433 * A lookup table (called addressbits) is used to filter
434 * the bits from the byte they are in.
435 * A marginal optimisation is possible by having three
436 * different lookup tables.
437 * One as we have now (for b0), one for b2
438 * (that would avoid the >> 1), and one for b1 (with all values
439 * << 4). However it was felt that introducing two more tables
440 * hardly justify the gain.
442 * The b2 shift is there to get rid of the lowest two bits.
443 * We could also do addressbits[b2] >> 1 but for the
444 * performace it does not make any difference
446 byte_addr = (addressbits[b1] << 4) + addressbits[b0];
447 bit_addr = addressbits[b2 >> 2];
449 buf[byte_addr] ^= (1 << bit_addr);
453 /* count nr of bits; use table lookup, faster than calculating it */
454 if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1)
455 return 1; /* error in ecc data; no action needed */
457 printk(KERN_ERR "uncorrectable error : ");
460 EXPORT_SYMBOL(nand_correct_data);
462 MODULE_LICENSE("GPL");
463 MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>");
464 MODULE_DESCRIPTION("Generic NAND ECC support");