forked from Minki/linux
d8467112d6
Before the introduction of the ECC framework infrastructure, many drivers used the ->calculate/correct() Hamming helpers directly. The point of this framework was to avoid this kind of hackish calls and use a proper and generic API but it is true that in certain cases, drivers still need to use these helpers in order to do ECC computations on behalf of their limited hardware. Right after the introduction of the ECC engine core introduction, it was spotted that it was not possible to use the shiny rawnand software ECC helpers so easily because an ECC engine object should have been allocated and initialized first. While this works well in most cases, for these drivers just leveraging the power of a single helper in conjunction with some pretty old and limited hardware, it did not fit. The idea back then was to declare intermediate helpers which would make use of the exported software ECC engine bare functions while keeping the rawnand layer compatibility. As there was already functions with the rawnand_sw_hamming_ prefix it was decided to declare new local helpers for this purpose in each driver needing one. Besides being far from optimal, this design choice was blamed by Linus when he pulled the "fixes" pull request [1] so that is why now it is time to clean this mess up. Enhancing the implementation of the rawnand_ecc_sw_* helpers to support both cases, when the ECC object is instantiated and when it is not is a quite elegant way to solve this situation. This way, we can still use the existing and exported rawnand helpers while avoiding the need for each driver to declare its own helper. Following this change, most of the fixes sent in [2] can now be safely reverted. Only the fsmc fix will need to be kept because there is actually something specific to the driver to do in its ->correct() helper. [1] https://lore.kernel.org/lkml/CAHk-=wh_ZHF685Fni8V9is17mj=pFisUaZ_0=gq6nbK+ZcyQmg@mail.gmail.com/ [2] https://lore.kernel.org/linux-mtd/20210413161840.345208-1-miquel.raynal@bootlin.com/ Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com> Link: https://lore.kernel.org/linux-mtd/20210928221507.199198-3-miquel.raynal@bootlin.com
661 lines
19 KiB
C
661 lines
19 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* This file contains an ECC algorithm that detects and corrects 1 bit
|
|
* errors in a 256 byte block of data.
|
|
*
|
|
* Copyright © 2008 Koninklijke Philips Electronics NV.
|
|
* Author: Frans Meulenbroeks
|
|
*
|
|
* Completely replaces the previous ECC implementation which was written by:
|
|
* Steven J. Hill (sjhill@realitydiluted.com)
|
|
* Thomas Gleixner (tglx@linutronix.de)
|
|
*
|
|
* Information on how this algorithm works and how it was developed
|
|
* can be found in Documentation/driver-api/mtd/nand_ecc.rst
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mtd/nand.h>
|
|
#include <linux/mtd/nand-ecc-sw-hamming.h>
|
|
#include <linux/slab.h>
|
|
#include <asm/byteorder.h>
|
|
|
|
/*
|
|
* invparity is a 256 byte table that contains the odd parity
|
|
* for each byte. So if the number of bits in a byte is even,
|
|
* the array element is 1, and when the number of bits is odd
|
|
* the array eleemnt is 0.
|
|
*/
|
|
static const char invparity[256] = {
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
|
|
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
|
|
};
|
|
|
|
/*
|
|
* bitsperbyte contains the number of bits per byte
|
|
* this is only used for testing and repairing parity
|
|
* (a precalculated value slightly improves performance)
|
|
*/
|
|
static const char bitsperbyte[256] = {
|
|
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
|
|
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
|
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
|
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
|
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
|
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
|
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
|
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
|
|
};
|
|
|
|
/*
|
|
* addressbits is a lookup table to filter out the bits from the xor-ed
|
|
* ECC data that identify the faulty location.
|
|
* this is only used for repairing parity
|
|
* see the comments in nand_ecc_sw_hamming_correct for more details
|
|
*/
|
|
static const char addressbits[256] = {
|
|
0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
|
|
0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
|
|
0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
|
|
0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
|
|
0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
|
|
0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
|
|
0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
|
|
0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
|
|
0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
|
|
0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
|
|
0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
|
|
0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
|
|
0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
|
|
0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
|
|
0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
|
|
0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
|
|
0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
|
|
0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
|
|
0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
|
|
0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
|
|
0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
|
|
0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
|
|
0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
|
|
0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
|
|
0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
|
|
0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
|
|
0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
|
|
0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
|
|
0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
|
|
0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
|
|
0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
|
|
0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f
|
|
};
|
|
|
|
int ecc_sw_hamming_calculate(const unsigned char *buf, unsigned int step_size,
|
|
unsigned char *code, bool sm_order)
|
|
{
|
|
const u32 *bp = (uint32_t *)buf;
|
|
const u32 eccsize_mult = (step_size == 256) ? 1 : 2;
|
|
/* current value in buffer */
|
|
u32 cur;
|
|
/* rp0..rp17 are the various accumulated parities (per byte) */
|
|
u32 rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7, rp8, rp9, rp10, rp11, rp12,
|
|
rp13, rp14, rp15, rp16, rp17;
|
|
/* Cumulative parity for all data */
|
|
u32 par;
|
|
/* Cumulative parity at the end of the loop (rp12, rp14, rp16) */
|
|
u32 tmppar;
|
|
int i;
|
|
|
|
par = 0;
|
|
rp4 = 0;
|
|
rp6 = 0;
|
|
rp8 = 0;
|
|
rp10 = 0;
|
|
rp12 = 0;
|
|
rp14 = 0;
|
|
rp16 = 0;
|
|
rp17 = 0;
|
|
|
|
/*
|
|
* The loop is unrolled a number of times;
|
|
* This avoids if statements to decide on which rp value to update
|
|
* Also we process the data by longwords.
|
|
* Note: passing unaligned data might give a performance penalty.
|
|
* It is assumed that the buffers are aligned.
|
|
* tmppar is the cumulative sum of this iteration.
|
|
* needed for calculating rp12, rp14, rp16 and par
|
|
* also used as a performance improvement for rp6, rp8 and rp10
|
|
*/
|
|
for (i = 0; i < eccsize_mult << 2; i++) {
|
|
cur = *bp++;
|
|
tmppar = cur;
|
|
rp4 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp6 ^= tmppar;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp8 ^= tmppar;
|
|
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
rp6 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp6 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp10 ^= tmppar;
|
|
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
rp6 ^= cur;
|
|
rp8 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp6 ^= cur;
|
|
rp8 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
rp8 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp8 ^= cur;
|
|
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
rp6 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp6 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
rp4 ^= cur;
|
|
cur = *bp++;
|
|
tmppar ^= cur;
|
|
|
|
par ^= tmppar;
|
|
if ((i & 0x1) == 0)
|
|
rp12 ^= tmppar;
|
|
if ((i & 0x2) == 0)
|
|
rp14 ^= tmppar;
|
|
if (eccsize_mult == 2 && (i & 0x4) == 0)
|
|
rp16 ^= tmppar;
|
|
}
|
|
|
|
/*
|
|
* handle the fact that we use longword operations
|
|
* we'll bring rp4..rp14..rp16 back to single byte entities by
|
|
* shifting and xoring first fold the upper and lower 16 bits,
|
|
* then the upper and lower 8 bits.
|
|
*/
|
|
rp4 ^= (rp4 >> 16);
|
|
rp4 ^= (rp4 >> 8);
|
|
rp4 &= 0xff;
|
|
rp6 ^= (rp6 >> 16);
|
|
rp6 ^= (rp6 >> 8);
|
|
rp6 &= 0xff;
|
|
rp8 ^= (rp8 >> 16);
|
|
rp8 ^= (rp8 >> 8);
|
|
rp8 &= 0xff;
|
|
rp10 ^= (rp10 >> 16);
|
|
rp10 ^= (rp10 >> 8);
|
|
rp10 &= 0xff;
|
|
rp12 ^= (rp12 >> 16);
|
|
rp12 ^= (rp12 >> 8);
|
|
rp12 &= 0xff;
|
|
rp14 ^= (rp14 >> 16);
|
|
rp14 ^= (rp14 >> 8);
|
|
rp14 &= 0xff;
|
|
if (eccsize_mult == 2) {
|
|
rp16 ^= (rp16 >> 16);
|
|
rp16 ^= (rp16 >> 8);
|
|
rp16 &= 0xff;
|
|
}
|
|
|
|
/*
|
|
* we also need to calculate the row parity for rp0..rp3
|
|
* This is present in par, because par is now
|
|
* rp3 rp3 rp2 rp2 in little endian and
|
|
* rp2 rp2 rp3 rp3 in big endian
|
|
* as well as
|
|
* rp1 rp0 rp1 rp0 in little endian and
|
|
* rp0 rp1 rp0 rp1 in big endian
|
|
* First calculate rp2 and rp3
|
|
*/
|
|
#ifdef __BIG_ENDIAN
|
|
rp2 = (par >> 16);
|
|
rp2 ^= (rp2 >> 8);
|
|
rp2 &= 0xff;
|
|
rp3 = par & 0xffff;
|
|
rp3 ^= (rp3 >> 8);
|
|
rp3 &= 0xff;
|
|
#else
|
|
rp3 = (par >> 16);
|
|
rp3 ^= (rp3 >> 8);
|
|
rp3 &= 0xff;
|
|
rp2 = par & 0xffff;
|
|
rp2 ^= (rp2 >> 8);
|
|
rp2 &= 0xff;
|
|
#endif
|
|
|
|
/* reduce par to 16 bits then calculate rp1 and rp0 */
|
|
par ^= (par >> 16);
|
|
#ifdef __BIG_ENDIAN
|
|
rp0 = (par >> 8) & 0xff;
|
|
rp1 = (par & 0xff);
|
|
#else
|
|
rp1 = (par >> 8) & 0xff;
|
|
rp0 = (par & 0xff);
|
|
#endif
|
|
|
|
/* finally reduce par to 8 bits */
|
|
par ^= (par >> 8);
|
|
par &= 0xff;
|
|
|
|
/*
|
|
* and calculate rp5..rp15..rp17
|
|
* note that par = rp4 ^ rp5 and due to the commutative property
|
|
* of the ^ operator we can say:
|
|
* rp5 = (par ^ rp4);
|
|
* The & 0xff seems superfluous, but benchmarking learned that
|
|
* leaving it out gives slightly worse results. No idea why, probably
|
|
* it has to do with the way the pipeline in pentium is organized.
|
|
*/
|
|
rp5 = (par ^ rp4) & 0xff;
|
|
rp7 = (par ^ rp6) & 0xff;
|
|
rp9 = (par ^ rp8) & 0xff;
|
|
rp11 = (par ^ rp10) & 0xff;
|
|
rp13 = (par ^ rp12) & 0xff;
|
|
rp15 = (par ^ rp14) & 0xff;
|
|
if (eccsize_mult == 2)
|
|
rp17 = (par ^ rp16) & 0xff;
|
|
|
|
/*
|
|
* Finally calculate the ECC bits.
|
|
* Again here it might seem that there are performance optimisations
|
|
* possible, but benchmarks showed that on the system this is developed
|
|
* the code below is the fastest
|
|
*/
|
|
if (sm_order) {
|
|
code[0] = (invparity[rp7] << 7) | (invparity[rp6] << 6) |
|
|
(invparity[rp5] << 5) | (invparity[rp4] << 4) |
|
|
(invparity[rp3] << 3) | (invparity[rp2] << 2) |
|
|
(invparity[rp1] << 1) | (invparity[rp0]);
|
|
code[1] = (invparity[rp15] << 7) | (invparity[rp14] << 6) |
|
|
(invparity[rp13] << 5) | (invparity[rp12] << 4) |
|
|
(invparity[rp11] << 3) | (invparity[rp10] << 2) |
|
|
(invparity[rp9] << 1) | (invparity[rp8]);
|
|
} else {
|
|
code[1] = (invparity[rp7] << 7) | (invparity[rp6] << 6) |
|
|
(invparity[rp5] << 5) | (invparity[rp4] << 4) |
|
|
(invparity[rp3] << 3) | (invparity[rp2] << 2) |
|
|
(invparity[rp1] << 1) | (invparity[rp0]);
|
|
code[0] = (invparity[rp15] << 7) | (invparity[rp14] << 6) |
|
|
(invparity[rp13] << 5) | (invparity[rp12] << 4) |
|
|
(invparity[rp11] << 3) | (invparity[rp10] << 2) |
|
|
(invparity[rp9] << 1) | (invparity[rp8]);
|
|
}
|
|
|
|
if (eccsize_mult == 1)
|
|
code[2] =
|
|
(invparity[par & 0xf0] << 7) |
|
|
(invparity[par & 0x0f] << 6) |
|
|
(invparity[par & 0xcc] << 5) |
|
|
(invparity[par & 0x33] << 4) |
|
|
(invparity[par & 0xaa] << 3) |
|
|
(invparity[par & 0x55] << 2) |
|
|
3;
|
|
else
|
|
code[2] =
|
|
(invparity[par & 0xf0] << 7) |
|
|
(invparity[par & 0x0f] << 6) |
|
|
(invparity[par & 0xcc] << 5) |
|
|
(invparity[par & 0x33] << 4) |
|
|
(invparity[par & 0xaa] << 3) |
|
|
(invparity[par & 0x55] << 2) |
|
|
(invparity[rp17] << 1) |
|
|
(invparity[rp16] << 0);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(ecc_sw_hamming_calculate);
|
|
|
|
/**
|
|
* nand_ecc_sw_hamming_calculate - Calculate 3-byte ECC for 256/512-byte block
|
|
* @nand: NAND device
|
|
* @buf: Input buffer with raw data
|
|
* @code: Output buffer with ECC
|
|
*/
|
|
int nand_ecc_sw_hamming_calculate(struct nand_device *nand,
|
|
const unsigned char *buf, unsigned char *code)
|
|
{
|
|
struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;
|
|
unsigned int step_size = nand->ecc.ctx.conf.step_size;
|
|
bool sm_order = engine_conf ? engine_conf->sm_order : false;
|
|
|
|
return ecc_sw_hamming_calculate(buf, step_size, code, sm_order);
|
|
}
|
|
EXPORT_SYMBOL(nand_ecc_sw_hamming_calculate);
|
|
|
|
int ecc_sw_hamming_correct(unsigned char *buf, unsigned char *read_ecc,
|
|
unsigned char *calc_ecc, unsigned int step_size,
|
|
bool sm_order)
|
|
{
|
|
const u32 eccsize_mult = step_size >> 8;
|
|
unsigned char b0, b1, b2, bit_addr;
|
|
unsigned int byte_addr;
|
|
|
|
/*
|
|
* b0 to b2 indicate which bit is faulty (if any)
|
|
* we might need the xor result more than once,
|
|
* so keep them in a local var
|
|
*/
|
|
if (sm_order) {
|
|
b0 = read_ecc[0] ^ calc_ecc[0];
|
|
b1 = read_ecc[1] ^ calc_ecc[1];
|
|
} else {
|
|
b0 = read_ecc[1] ^ calc_ecc[1];
|
|
b1 = read_ecc[0] ^ calc_ecc[0];
|
|
}
|
|
|
|
b2 = read_ecc[2] ^ calc_ecc[2];
|
|
|
|
/* check if there are any bitfaults */
|
|
|
|
/* repeated if statements are slightly more efficient than switch ... */
|
|
/* ordered in order of likelihood */
|
|
|
|
if ((b0 | b1 | b2) == 0)
|
|
return 0; /* no error */
|
|
|
|
if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) &&
|
|
(((b1 ^ (b1 >> 1)) & 0x55) == 0x55) &&
|
|
((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) ||
|
|
(eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) {
|
|
/* single bit error */
|
|
/*
|
|
* rp17/rp15/13/11/9/7/5/3/1 indicate which byte is the faulty
|
|
* byte, cp 5/3/1 indicate the faulty bit.
|
|
* A lookup table (called addressbits) is used to filter
|
|
* the bits from the byte they are in.
|
|
* A marginal optimisation is possible by having three
|
|
* different lookup tables.
|
|
* One as we have now (for b0), one for b2
|
|
* (that would avoid the >> 1), and one for b1 (with all values
|
|
* << 4). However it was felt that introducing two more tables
|
|
* hardly justify the gain.
|
|
*
|
|
* The b2 shift is there to get rid of the lowest two bits.
|
|
* We could also do addressbits[b2] >> 1 but for the
|
|
* performance it does not make any difference
|
|
*/
|
|
if (eccsize_mult == 1)
|
|
byte_addr = (addressbits[b1] << 4) + addressbits[b0];
|
|
else
|
|
byte_addr = (addressbits[b2 & 0x3] << 8) +
|
|
(addressbits[b1] << 4) + addressbits[b0];
|
|
bit_addr = addressbits[b2 >> 2];
|
|
/* flip the bit */
|
|
buf[byte_addr] ^= (1 << bit_addr);
|
|
return 1;
|
|
|
|
}
|
|
/* count nr of bits; use table lookup, faster than calculating it */
|
|
if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1)
|
|
return 1; /* error in ECC data; no action needed */
|
|
|
|
pr_err("%s: uncorrectable ECC error\n", __func__);
|
|
return -EBADMSG;
|
|
}
|
|
EXPORT_SYMBOL(ecc_sw_hamming_correct);
|
|
|
|
/**
|
|
* nand_ecc_sw_hamming_correct - Detect and correct bit error(s)
|
|
* @nand: NAND device
|
|
* @buf: Raw data read from the chip
|
|
* @read_ecc: ECC bytes read from the chip
|
|
* @calc_ecc: ECC calculated from the raw data
|
|
*
|
|
* Detect and correct up to 1 bit error per 256/512-byte block.
|
|
*/
|
|
int nand_ecc_sw_hamming_correct(struct nand_device *nand, unsigned char *buf,
|
|
unsigned char *read_ecc,
|
|
unsigned char *calc_ecc)
|
|
{
|
|
struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;
|
|
unsigned int step_size = nand->ecc.ctx.conf.step_size;
|
|
bool sm_order = engine_conf ? engine_conf->sm_order : false;
|
|
|
|
return ecc_sw_hamming_correct(buf, read_ecc, calc_ecc, step_size,
|
|
sm_order);
|
|
}
|
|
EXPORT_SYMBOL(nand_ecc_sw_hamming_correct);
|
|
|
|
int nand_ecc_sw_hamming_init_ctx(struct nand_device *nand)
|
|
{
|
|
struct nand_ecc_props *conf = &nand->ecc.ctx.conf;
|
|
struct nand_ecc_sw_hamming_conf *engine_conf;
|
|
struct mtd_info *mtd = nanddev_to_mtd(nand);
|
|
int ret;
|
|
|
|
if (!mtd->ooblayout) {
|
|
switch (mtd->oobsize) {
|
|
case 8:
|
|
case 16:
|
|
mtd_set_ooblayout(mtd, nand_get_small_page_ooblayout());
|
|
break;
|
|
case 64:
|
|
case 128:
|
|
mtd_set_ooblayout(mtd,
|
|
nand_get_large_page_hamming_ooblayout());
|
|
break;
|
|
default:
|
|
return -ENOTSUPP;
|
|
}
|
|
}
|
|
|
|
conf->engine_type = NAND_ECC_ENGINE_TYPE_SOFT;
|
|
conf->algo = NAND_ECC_ALGO_HAMMING;
|
|
conf->step_size = nand->ecc.user_conf.step_size;
|
|
conf->strength = 1;
|
|
|
|
/* Use the strongest configuration by default */
|
|
if (conf->step_size != 256 && conf->step_size != 512)
|
|
conf->step_size = 256;
|
|
|
|
engine_conf = kzalloc(sizeof(*engine_conf), GFP_KERNEL);
|
|
if (!engine_conf)
|
|
return -ENOMEM;
|
|
|
|
ret = nand_ecc_init_req_tweaking(&engine_conf->req_ctx, nand);
|
|
if (ret)
|
|
goto free_engine_conf;
|
|
|
|
engine_conf->code_size = 3;
|
|
engine_conf->calc_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
|
|
engine_conf->code_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
|
|
if (!engine_conf->calc_buf || !engine_conf->code_buf) {
|
|
ret = -ENOMEM;
|
|
goto free_bufs;
|
|
}
|
|
|
|
nand->ecc.ctx.priv = engine_conf;
|
|
nand->ecc.ctx.nsteps = mtd->writesize / conf->step_size;
|
|
nand->ecc.ctx.total = nand->ecc.ctx.nsteps * engine_conf->code_size;
|
|
|
|
return 0;
|
|
|
|
free_bufs:
|
|
nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx);
|
|
kfree(engine_conf->calc_buf);
|
|
kfree(engine_conf->code_buf);
|
|
free_engine_conf:
|
|
kfree(engine_conf);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(nand_ecc_sw_hamming_init_ctx);
|
|
|
|
void nand_ecc_sw_hamming_cleanup_ctx(struct nand_device *nand)
|
|
{
|
|
struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;
|
|
|
|
if (engine_conf) {
|
|
nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx);
|
|
kfree(engine_conf->calc_buf);
|
|
kfree(engine_conf->code_buf);
|
|
kfree(engine_conf);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(nand_ecc_sw_hamming_cleanup_ctx);
|
|
|
|
static int nand_ecc_sw_hamming_prepare_io_req(struct nand_device *nand,
|
|
struct nand_page_io_req *req)
|
|
{
|
|
struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;
|
|
struct mtd_info *mtd = nanddev_to_mtd(nand);
|
|
int eccsize = nand->ecc.ctx.conf.step_size;
|
|
int eccbytes = engine_conf->code_size;
|
|
int eccsteps = nand->ecc.ctx.nsteps;
|
|
int total = nand->ecc.ctx.total;
|
|
u8 *ecccalc = engine_conf->calc_buf;
|
|
const u8 *data;
|
|
int i;
|
|
|
|
/* Nothing to do for a raw operation */
|
|
if (req->mode == MTD_OPS_RAW)
|
|
return 0;
|
|
|
|
/* This engine does not provide BBM/free OOB bytes protection */
|
|
if (!req->datalen)
|
|
return 0;
|
|
|
|
nand_ecc_tweak_req(&engine_conf->req_ctx, req);
|
|
|
|
/* No more preparation for page read */
|
|
if (req->type == NAND_PAGE_READ)
|
|
return 0;
|
|
|
|
/* Preparation for page write: derive the ECC bytes and place them */
|
|
for (i = 0, data = req->databuf.out;
|
|
eccsteps;
|
|
eccsteps--, i += eccbytes, data += eccsize)
|
|
nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]);
|
|
|
|
return mtd_ooblayout_set_eccbytes(mtd, ecccalc, (void *)req->oobbuf.out,
|
|
0, total);
|
|
}
|
|
|
|
static int nand_ecc_sw_hamming_finish_io_req(struct nand_device *nand,
|
|
struct nand_page_io_req *req)
|
|
{
|
|
struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;
|
|
struct mtd_info *mtd = nanddev_to_mtd(nand);
|
|
int eccsize = nand->ecc.ctx.conf.step_size;
|
|
int total = nand->ecc.ctx.total;
|
|
int eccbytes = engine_conf->code_size;
|
|
int eccsteps = nand->ecc.ctx.nsteps;
|
|
u8 *ecccalc = engine_conf->calc_buf;
|
|
u8 *ecccode = engine_conf->code_buf;
|
|
unsigned int max_bitflips = 0;
|
|
u8 *data = req->databuf.in;
|
|
int i, ret;
|
|
|
|
/* Nothing to do for a raw operation */
|
|
if (req->mode == MTD_OPS_RAW)
|
|
return 0;
|
|
|
|
/* This engine does not provide BBM/free OOB bytes protection */
|
|
if (!req->datalen)
|
|
return 0;
|
|
|
|
/* No more preparation for page write */
|
|
if (req->type == NAND_PAGE_WRITE) {
|
|
nand_ecc_restore_req(&engine_conf->req_ctx, req);
|
|
return 0;
|
|
}
|
|
|
|
/* Finish a page read: retrieve the (raw) ECC bytes*/
|
|
ret = mtd_ooblayout_get_eccbytes(mtd, ecccode, req->oobbuf.in, 0,
|
|
total);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Calculate the ECC bytes */
|
|
for (i = 0; eccsteps; eccsteps--, i += eccbytes, data += eccsize)
|
|
nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]);
|
|
|
|
/* Finish a page read: compare and correct */
|
|
for (eccsteps = nand->ecc.ctx.nsteps, i = 0, data = req->databuf.in;
|
|
eccsteps;
|
|
eccsteps--, i += eccbytes, data += eccsize) {
|
|
int stat = nand_ecc_sw_hamming_correct(nand, data,
|
|
&ecccode[i],
|
|
&ecccalc[i]);
|
|
if (stat < 0) {
|
|
mtd->ecc_stats.failed++;
|
|
} else {
|
|
mtd->ecc_stats.corrected += stat;
|
|
max_bitflips = max_t(unsigned int, max_bitflips, stat);
|
|
}
|
|
}
|
|
|
|
nand_ecc_restore_req(&engine_conf->req_ctx, req);
|
|
|
|
return max_bitflips;
|
|
}
|
|
|
|
static struct nand_ecc_engine_ops nand_ecc_sw_hamming_engine_ops = {
|
|
.init_ctx = nand_ecc_sw_hamming_init_ctx,
|
|
.cleanup_ctx = nand_ecc_sw_hamming_cleanup_ctx,
|
|
.prepare_io_req = nand_ecc_sw_hamming_prepare_io_req,
|
|
.finish_io_req = nand_ecc_sw_hamming_finish_io_req,
|
|
};
|
|
|
|
static struct nand_ecc_engine nand_ecc_sw_hamming_engine = {
|
|
.ops = &nand_ecc_sw_hamming_engine_ops,
|
|
};
|
|
|
|
struct nand_ecc_engine *nand_ecc_sw_hamming_get_engine(void)
|
|
{
|
|
return &nand_ecc_sw_hamming_engine;
|
|
}
|
|
EXPORT_SYMBOL(nand_ecc_sw_hamming_get_engine);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>");
|
|
MODULE_DESCRIPTION("NAND software Hamming ECC support");
|