// 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 #include #include #include #include #include #include /* * 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 const 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 "); MODULE_DESCRIPTION("NAND software Hamming ECC support");