[MTD] [NAND] nand_ecc.c: adding support for 512 byte ecc

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/mtd/mtd.h>

#include <linux/mtd/nand.h>

#include <linux/mtd/nand_ecc.h>

#include <asm/byteorder.h>

#else

};

/**

 * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256-byte block

 * @mtd:	MTD block structure (unused)

 * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte

 *			 block

 * @mtd:	MTD block structure

 * @buf:	input buffer with raw data

 * @code:	output buffer with ECC

 */

{

	int i;

	const uint32_t *bp = (uint32_t *)buf;

	/* 256 or 512 bytes/ecc  */

	const uint32_t eccsize_mult =

			(((struct nand_chip *)mtd->priv)->ecc.size) >> 8;

	uint32_t cur;		/* current value in buffer */

	/* rp0..rp15 are the various accumulated parities (per byte) */

	/* rp0..rp15..rp17 are the various accumulated parities (per byte) */

	uint32_t rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7;

	uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15;

	uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15, rp16;

	uint32_t uninitialized_var(rp17);	/* to make compiler happy */

	uint32_t par;		/* the cumulative parity for all data */

	uint32_t tmppar;	/* the cumulative parity for this iteration;

				   for rp12 and rp14 at the end of the loop */

				   for rp12, rp14 and rp16 at the end of the

				   loop */

	par = 0;

	rp4 = 0;

	rp10 = 0;

	rp12 = 0;

	rp14 = 0;

	rp16 = 0;

	/*

	 * The loop is unrolled a number of times;

	 * 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 and par

	 * needed for calculating rp12, rp14, rp16 and par

	 * also used as a performance improvement for rp6, rp8 and rp10

	 */

	for (i = 0; i < 4; i++) {

	for (i = 0; i < eccsize_mult << 2; i++) {

		cur = *bp++;

		tmppar = cur;

		rp4 ^= cur;

			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 back to single byte entities by shifting and

	 * xoring first fold the upper and lower 16 bits,

	 * 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);

	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

	par &= 0xff;

	/*

	 * and calculate rp5..rp15

	 * 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);

	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.

	    (invparity[rp9] << 1)  |

	    (invparity[rp8]);

#endif

	if (eccsize_mult == 1)

		code[2] =

		    (invparity[par & 0xf0] << 7) |

		    (invparity[par & 0x0f] << 6) |

		    (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(nand_calculate_ecc);

/**

 * nand_correct_data - [NAND Interface] Detect and correct bit error(s)

 * @mtd:	MTD block structure (unused)

 * @mtd:	MTD block structure

 * @buf:	raw data read from the chip

 * @read_ecc:	ECC from the chip

 * @calc_ecc:	the ECC calculated from raw data

 *

 * Detect and correct a 1 bit error for 256 byte block

 * Detect and correct a 1 bit error for 256/512 byte block

 */

int nand_correct_data(struct mtd_info *mtd, unsigned char *buf,

		      unsigned char *read_ecc, unsigned char *calc_ecc)

{

	unsigned char b0, b1, b2;

	unsigned char byte_addr, bit_addr;

	/* 256 or 512 bytes/ecc  */

	const uint32_t eccsize_mult =

			(((struct nand_chip *)mtd->priv)->ecc.size) >> 8;

	/*

	 * b0 to b2 indicate which bit is faulty (if any)

	if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) &&

	    (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) &&

	    (((b2 ^ (b2 >> 1)) & 0x54) == 0x54)) { /* single bit error */

	    ((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) ||

	     (eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) {

	/* single bit error */

		/*

		 * rp15/13/11/9/7/5/3/1 indicate which byte is the faulty byte

		 * cp 5/3/1 indicate the faulty bit.

		 * 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

		 * We could also do addressbits[b2] >> 1 but for the

		 * performace 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);