1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * This file contains an ECC algorithm that detects and corrects 1 bit 4 * errors in a 256 byte block of data. 5 * 6 * Copyright © 2008 Koninklijke Philips Electronics NV. 7 * Author: Frans Meulenbroeks 8 * 9 * Completely replaces the previous ECC implementation which was written by: 10 * Steven J. Hill (sjhill@realitydiluted.com) 11 * Thomas Gleixner (tglx@linutronix.de) 12 * 13 * Information on how this algorithm works and how it was developed 14 * can be found in Documentation/driver-api/mtd/nand_ecc.rst 15 */ 16 17 #include <linux/types.h> 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/mtd/nand.h> 21 #include <linux/mtd/nand-ecc-sw-hamming.h> 22 #include <linux/slab.h> 23 #include <asm/byteorder.h> 24 25 /* 26 * invparity is a 256 byte table that contains the odd parity 27 * for each byte. So if the number of bits in a byte is even, 28 * the array element is 1, and when the number of bits is odd 29 * the array eleemnt is 0. 30 */ 31 static const char invparity[256] = { 32 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 33 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 34 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 35 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 36 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 37 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 38 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 39 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 40 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 41 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 42 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 43 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 44 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 45 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 46 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 47 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1 48 }; 49 50 /* 51 * bitsperbyte contains the number of bits per byte 52 * this is only used for testing and repairing parity 53 * (a precalculated value slightly improves performance) 54 */ 55 static const char bitsperbyte[256] = { 56 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 57 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 58 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 59 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 60 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 61 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 62 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 63 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 64 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 65 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 66 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 67 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 68 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 69 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 70 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 71 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, 72 }; 73 74 /* 75 * addressbits is a lookup table to filter out the bits from the xor-ed 76 * ECC data that identify the faulty location. 77 * this is only used for repairing parity 78 * see the comments in nand_ecc_sw_hamming_correct for more details 79 */ 80 static const char addressbits[256] = { 81 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 82 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 83 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 84 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 85 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 86 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 87 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 88 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 89 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 90 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 91 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 92 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 93 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 94 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 95 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 96 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 97 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 98 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 99 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 100 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 101 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 102 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 103 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 104 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 105 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 106 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 107 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 108 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 109 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 110 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 111 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 112 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f 113 }; 114 115 int ecc_sw_hamming_calculate(const unsigned char *buf, unsigned int step_size, 116 unsigned char *code, bool sm_order) 117 { 118 const u32 *bp = (uint32_t *)buf; 119 const u32 eccsize_mult = (step_size == 256) ? 1 : 2; 120 /* current value in buffer */ 121 u32 cur; 122 /* rp0..rp17 are the various accumulated parities (per byte) */ 123 u32 rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7, rp8, rp9, rp10, rp11, rp12, 124 rp13, rp14, rp15, rp16, rp17; 125 /* Cumulative parity for all data */ 126 u32 par; 127 /* Cumulative parity at the end of the loop (rp12, rp14, rp16) */ 128 u32 tmppar; 129 int i; 130 131 par = 0; 132 rp4 = 0; 133 rp6 = 0; 134 rp8 = 0; 135 rp10 = 0; 136 rp12 = 0; 137 rp14 = 0; 138 rp16 = 0; 139 rp17 = 0; 140 141 /* 142 * The loop is unrolled a number of times; 143 * This avoids if statements to decide on which rp value to update 144 * Also we process the data by longwords. 145 * Note: passing unaligned data might give a performance penalty. 146 * It is assumed that the buffers are aligned. 147 * tmppar is the cumulative sum of this iteration. 148 * needed for calculating rp12, rp14, rp16 and par 149 * also used as a performance improvement for rp6, rp8 and rp10 150 */ 151 for (i = 0; i < eccsize_mult << 2; i++) { 152 cur = *bp++; 153 tmppar = cur; 154 rp4 ^= cur; 155 cur = *bp++; 156 tmppar ^= cur; 157 rp6 ^= tmppar; 158 cur = *bp++; 159 tmppar ^= cur; 160 rp4 ^= cur; 161 cur = *bp++; 162 tmppar ^= cur; 163 rp8 ^= tmppar; 164 165 cur = *bp++; 166 tmppar ^= cur; 167 rp4 ^= cur; 168 rp6 ^= cur; 169 cur = *bp++; 170 tmppar ^= cur; 171 rp6 ^= cur; 172 cur = *bp++; 173 tmppar ^= cur; 174 rp4 ^= cur; 175 cur = *bp++; 176 tmppar ^= cur; 177 rp10 ^= tmppar; 178 179 cur = *bp++; 180 tmppar ^= cur; 181 rp4 ^= cur; 182 rp6 ^= cur; 183 rp8 ^= cur; 184 cur = *bp++; 185 tmppar ^= cur; 186 rp6 ^= cur; 187 rp8 ^= cur; 188 cur = *bp++; 189 tmppar ^= cur; 190 rp4 ^= cur; 191 rp8 ^= cur; 192 cur = *bp++; 193 tmppar ^= cur; 194 rp8 ^= cur; 195 196 cur = *bp++; 197 tmppar ^= cur; 198 rp4 ^= cur; 199 rp6 ^= cur; 200 cur = *bp++; 201 tmppar ^= cur; 202 rp6 ^= cur; 203 cur = *bp++; 204 tmppar ^= cur; 205 rp4 ^= cur; 206 cur = *bp++; 207 tmppar ^= cur; 208 209 par ^= tmppar; 210 if ((i & 0x1) == 0) 211 rp12 ^= tmppar; 212 if ((i & 0x2) == 0) 213 rp14 ^= tmppar; 214 if (eccsize_mult == 2 && (i & 0x4) == 0) 215 rp16 ^= tmppar; 216 } 217 218 /* 219 * handle the fact that we use longword operations 220 * we'll bring rp4..rp14..rp16 back to single byte entities by 221 * shifting and xoring first fold the upper and lower 16 bits, 222 * then the upper and lower 8 bits. 223 */ 224 rp4 ^= (rp4 >> 16); 225 rp4 ^= (rp4 >> 8); 226 rp4 &= 0xff; 227 rp6 ^= (rp6 >> 16); 228 rp6 ^= (rp6 >> 8); 229 rp6 &= 0xff; 230 rp8 ^= (rp8 >> 16); 231 rp8 ^= (rp8 >> 8); 232 rp8 &= 0xff; 233 rp10 ^= (rp10 >> 16); 234 rp10 ^= (rp10 >> 8); 235 rp10 &= 0xff; 236 rp12 ^= (rp12 >> 16); 237 rp12 ^= (rp12 >> 8); 238 rp12 &= 0xff; 239 rp14 ^= (rp14 >> 16); 240 rp14 ^= (rp14 >> 8); 241 rp14 &= 0xff; 242 if (eccsize_mult == 2) { 243 rp16 ^= (rp16 >> 16); 244 rp16 ^= (rp16 >> 8); 245 rp16 &= 0xff; 246 } 247 248 /* 249 * we also need to calculate the row parity for rp0..rp3 250 * This is present in par, because par is now 251 * rp3 rp3 rp2 rp2 in little endian and 252 * rp2 rp2 rp3 rp3 in big endian 253 * as well as 254 * rp1 rp0 rp1 rp0 in little endian and 255 * rp0 rp1 rp0 rp1 in big endian 256 * First calculate rp2 and rp3 257 */ 258 #ifdef __BIG_ENDIAN 259 rp2 = (par >> 16); 260 rp2 ^= (rp2 >> 8); 261 rp2 &= 0xff; 262 rp3 = par & 0xffff; 263 rp3 ^= (rp3 >> 8); 264 rp3 &= 0xff; 265 #else 266 rp3 = (par >> 16); 267 rp3 ^= (rp3 >> 8); 268 rp3 &= 0xff; 269 rp2 = par & 0xffff; 270 rp2 ^= (rp2 >> 8); 271 rp2 &= 0xff; 272 #endif 273 274 /* reduce par to 16 bits then calculate rp1 and rp0 */ 275 par ^= (par >> 16); 276 #ifdef __BIG_ENDIAN 277 rp0 = (par >> 8) & 0xff; 278 rp1 = (par & 0xff); 279 #else 280 rp1 = (par >> 8) & 0xff; 281 rp0 = (par & 0xff); 282 #endif 283 284 /* finally reduce par to 8 bits */ 285 par ^= (par >> 8); 286 par &= 0xff; 287 288 /* 289 * and calculate rp5..rp15..rp17 290 * note that par = rp4 ^ rp5 and due to the commutative property 291 * of the ^ operator we can say: 292 * rp5 = (par ^ rp4); 293 * The & 0xff seems superfluous, but benchmarking learned that 294 * leaving it out gives slightly worse results. No idea why, probably 295 * it has to do with the way the pipeline in pentium is organized. 296 */ 297 rp5 = (par ^ rp4) & 0xff; 298 rp7 = (par ^ rp6) & 0xff; 299 rp9 = (par ^ rp8) & 0xff; 300 rp11 = (par ^ rp10) & 0xff; 301 rp13 = (par ^ rp12) & 0xff; 302 rp15 = (par ^ rp14) & 0xff; 303 if (eccsize_mult == 2) 304 rp17 = (par ^ rp16) & 0xff; 305 306 /* 307 * Finally calculate the ECC bits. 308 * Again here it might seem that there are performance optimisations 309 * possible, but benchmarks showed that on the system this is developed 310 * the code below is the fastest 311 */ 312 if (sm_order) { 313 code[0] = (invparity[rp7] << 7) | (invparity[rp6] << 6) | 314 (invparity[rp5] << 5) | (invparity[rp4] << 4) | 315 (invparity[rp3] << 3) | (invparity[rp2] << 2) | 316 (invparity[rp1] << 1) | (invparity[rp0]); 317 code[1] = (invparity[rp15] << 7) | (invparity[rp14] << 6) | 318 (invparity[rp13] << 5) | (invparity[rp12] << 4) | 319 (invparity[rp11] << 3) | (invparity[rp10] << 2) | 320 (invparity[rp9] << 1) | (invparity[rp8]); 321 } else { 322 code[1] = (invparity[rp7] << 7) | (invparity[rp6] << 6) | 323 (invparity[rp5] << 5) | (invparity[rp4] << 4) | 324 (invparity[rp3] << 3) | (invparity[rp2] << 2) | 325 (invparity[rp1] << 1) | (invparity[rp0]); 326 code[0] = (invparity[rp15] << 7) | (invparity[rp14] << 6) | 327 (invparity[rp13] << 5) | (invparity[rp12] << 4) | 328 (invparity[rp11] << 3) | (invparity[rp10] << 2) | 329 (invparity[rp9] << 1) | (invparity[rp8]); 330 } 331 332 if (eccsize_mult == 1) 333 code[2] = 334 (invparity[par & 0xf0] << 7) | 335 (invparity[par & 0x0f] << 6) | 336 (invparity[par & 0xcc] << 5) | 337 (invparity[par & 0x33] << 4) | 338 (invparity[par & 0xaa] << 3) | 339 (invparity[par & 0x55] << 2) | 340 3; 341 else 342 code[2] = 343 (invparity[par & 0xf0] << 7) | 344 (invparity[par & 0x0f] << 6) | 345 (invparity[par & 0xcc] << 5) | 346 (invparity[par & 0x33] << 4) | 347 (invparity[par & 0xaa] << 3) | 348 (invparity[par & 0x55] << 2) | 349 (invparity[rp17] << 1) | 350 (invparity[rp16] << 0); 351 352 return 0; 353 } 354 EXPORT_SYMBOL(ecc_sw_hamming_calculate); 355 356 /** 357 * nand_ecc_sw_hamming_calculate - Calculate 3-byte ECC for 256/512-byte block 358 * @nand: NAND device 359 * @buf: Input buffer with raw data 360 * @code: Output buffer with ECC 361 */ 362 int nand_ecc_sw_hamming_calculate(struct nand_device *nand, 363 const unsigned char *buf, unsigned char *code) 364 { 365 struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv; 366 unsigned int step_size = nand->ecc.ctx.conf.step_size; 367 368 return ecc_sw_hamming_calculate(buf, step_size, code, 369 engine_conf->sm_order); 370 } 371 EXPORT_SYMBOL(nand_ecc_sw_hamming_calculate); 372 373 int ecc_sw_hamming_correct(unsigned char *buf, unsigned char *read_ecc, 374 unsigned char *calc_ecc, unsigned int step_size, 375 bool sm_order) 376 { 377 const u32 eccsize_mult = step_size >> 8; 378 unsigned char b0, b1, b2, bit_addr; 379 unsigned int byte_addr; 380 381 /* 382 * b0 to b2 indicate which bit is faulty (if any) 383 * we might need the xor result more than once, 384 * so keep them in a local var 385 */ 386 if (sm_order) { 387 b0 = read_ecc[0] ^ calc_ecc[0]; 388 b1 = read_ecc[1] ^ calc_ecc[1]; 389 } else { 390 b0 = read_ecc[1] ^ calc_ecc[1]; 391 b1 = read_ecc[0] ^ calc_ecc[0]; 392 } 393 394 b2 = read_ecc[2] ^ calc_ecc[2]; 395 396 /* check if there are any bitfaults */ 397 398 /* repeated if statements are slightly more efficient than switch ... */ 399 /* ordered in order of likelihood */ 400 401 if ((b0 | b1 | b2) == 0) 402 return 0; /* no error */ 403 404 if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) && 405 (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) && 406 ((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) || 407 (eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) { 408 /* single bit error */ 409 /* 410 * rp17/rp15/13/11/9/7/5/3/1 indicate which byte is the faulty 411 * byte, cp 5/3/1 indicate the faulty bit. 412 * A lookup table (called addressbits) is used to filter 413 * the bits from the byte they are in. 414 * A marginal optimisation is possible by having three 415 * different lookup tables. 416 * One as we have now (for b0), one for b2 417 * (that would avoid the >> 1), and one for b1 (with all values 418 * << 4). However it was felt that introducing two more tables 419 * hardly justify the gain. 420 * 421 * The b2 shift is there to get rid of the lowest two bits. 422 * We could also do addressbits[b2] >> 1 but for the 423 * performance it does not make any difference 424 */ 425 if (eccsize_mult == 1) 426 byte_addr = (addressbits[b1] << 4) + addressbits[b0]; 427 else 428 byte_addr = (addressbits[b2 & 0x3] << 8) + 429 (addressbits[b1] << 4) + addressbits[b0]; 430 bit_addr = addressbits[b2 >> 2]; 431 /* flip the bit */ 432 buf[byte_addr] ^= (1 << bit_addr); 433 return 1; 434 435 } 436 /* count nr of bits; use table lookup, faster than calculating it */ 437 if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1) 438 return 1; /* error in ECC data; no action needed */ 439 440 pr_err("%s: uncorrectable ECC error\n", __func__); 441 return -EBADMSG; 442 } 443 EXPORT_SYMBOL(ecc_sw_hamming_correct); 444 445 /** 446 * nand_ecc_sw_hamming_correct - Detect and correct bit error(s) 447 * @nand: NAND device 448 * @buf: Raw data read from the chip 449 * @read_ecc: ECC bytes read from the chip 450 * @calc_ecc: ECC calculated from the raw data 451 * 452 * Detect and correct up to 1 bit error per 256/512-byte block. 453 */ 454 int nand_ecc_sw_hamming_correct(struct nand_device *nand, unsigned char *buf, 455 unsigned char *read_ecc, 456 unsigned char *calc_ecc) 457 { 458 struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv; 459 unsigned int step_size = nand->ecc.ctx.conf.step_size; 460 461 return ecc_sw_hamming_correct(buf, read_ecc, calc_ecc, step_size, 462 engine_conf->sm_order); 463 } 464 EXPORT_SYMBOL(nand_ecc_sw_hamming_correct); 465 466 int nand_ecc_sw_hamming_init_ctx(struct nand_device *nand) 467 { 468 struct nand_ecc_props *conf = &nand->ecc.ctx.conf; 469 struct nand_ecc_sw_hamming_conf *engine_conf; 470 struct mtd_info *mtd = nanddev_to_mtd(nand); 471 int ret; 472 473 if (!mtd->ooblayout) { 474 switch (mtd->oobsize) { 475 case 8: 476 case 16: 477 mtd_set_ooblayout(mtd, nand_get_small_page_ooblayout()); 478 break; 479 case 64: 480 case 128: 481 mtd_set_ooblayout(mtd, 482 nand_get_large_page_hamming_ooblayout()); 483 break; 484 default: 485 return -ENOTSUPP; 486 } 487 } 488 489 conf->engine_type = NAND_ECC_ENGINE_TYPE_SOFT; 490 conf->algo = NAND_ECC_ALGO_HAMMING; 491 conf->step_size = nand->ecc.user_conf.step_size; 492 conf->strength = 1; 493 494 /* Use the strongest configuration by default */ 495 if (conf->step_size != 256 && conf->step_size != 512) 496 conf->step_size = 256; 497 498 engine_conf = kzalloc(sizeof(*engine_conf), GFP_KERNEL); 499 if (!engine_conf) 500 return -ENOMEM; 501 502 ret = nand_ecc_init_req_tweaking(&engine_conf->req_ctx, nand); 503 if (ret) 504 goto free_engine_conf; 505 506 engine_conf->code_size = 3; 507 engine_conf->nsteps = mtd->writesize / conf->step_size; 508 engine_conf->calc_buf = kzalloc(mtd->oobsize, GFP_KERNEL); 509 engine_conf->code_buf = kzalloc(mtd->oobsize, GFP_KERNEL); 510 if (!engine_conf->calc_buf || !engine_conf->code_buf) { 511 ret = -ENOMEM; 512 goto free_bufs; 513 } 514 515 nand->ecc.ctx.priv = engine_conf; 516 nand->ecc.ctx.total = engine_conf->nsteps * engine_conf->code_size; 517 518 return 0; 519 520 free_bufs: 521 nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx); 522 kfree(engine_conf->calc_buf); 523 kfree(engine_conf->code_buf); 524 free_engine_conf: 525 kfree(engine_conf); 526 527 return ret; 528 } 529 EXPORT_SYMBOL(nand_ecc_sw_hamming_init_ctx); 530 531 void nand_ecc_sw_hamming_cleanup_ctx(struct nand_device *nand) 532 { 533 struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv; 534 535 if (engine_conf) { 536 nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx); 537 kfree(engine_conf->calc_buf); 538 kfree(engine_conf->code_buf); 539 kfree(engine_conf); 540 } 541 } 542 EXPORT_SYMBOL(nand_ecc_sw_hamming_cleanup_ctx); 543 544 static int nand_ecc_sw_hamming_prepare_io_req(struct nand_device *nand, 545 struct nand_page_io_req *req) 546 { 547 struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv; 548 struct mtd_info *mtd = nanddev_to_mtd(nand); 549 int eccsize = nand->ecc.ctx.conf.step_size; 550 int eccbytes = engine_conf->code_size; 551 int eccsteps = engine_conf->nsteps; 552 int total = nand->ecc.ctx.total; 553 u8 *ecccalc = engine_conf->calc_buf; 554 const u8 *data; 555 int i; 556 557 /* Nothing to do for a raw operation */ 558 if (req->mode == MTD_OPS_RAW) 559 return 0; 560 561 /* This engine does not provide BBM/free OOB bytes protection */ 562 if (!req->datalen) 563 return 0; 564 565 nand_ecc_tweak_req(&engine_conf->req_ctx, req); 566 567 /* No more preparation for page read */ 568 if (req->type == NAND_PAGE_READ) 569 return 0; 570 571 /* Preparation for page write: derive the ECC bytes and place them */ 572 for (i = 0, data = req->databuf.out; 573 eccsteps; 574 eccsteps--, i += eccbytes, data += eccsize) 575 nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]); 576 577 return mtd_ooblayout_set_eccbytes(mtd, ecccalc, (void *)req->oobbuf.out, 578 0, total); 579 } 580 581 static int nand_ecc_sw_hamming_finish_io_req(struct nand_device *nand, 582 struct nand_page_io_req *req) 583 { 584 struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv; 585 struct mtd_info *mtd = nanddev_to_mtd(nand); 586 int eccsize = nand->ecc.ctx.conf.step_size; 587 int total = nand->ecc.ctx.total; 588 int eccbytes = engine_conf->code_size; 589 int eccsteps = engine_conf->nsteps; 590 u8 *ecccalc = engine_conf->calc_buf; 591 u8 *ecccode = engine_conf->code_buf; 592 unsigned int max_bitflips = 0; 593 u8 *data = req->databuf.in; 594 int i, ret; 595 596 /* Nothing to do for a raw operation */ 597 if (req->mode == MTD_OPS_RAW) 598 return 0; 599 600 /* This engine does not provide BBM/free OOB bytes protection */ 601 if (!req->datalen) 602 return 0; 603 604 /* No more preparation for page write */ 605 if (req->type == NAND_PAGE_WRITE) { 606 nand_ecc_restore_req(&engine_conf->req_ctx, req); 607 return 0; 608 } 609 610 /* Finish a page read: retrieve the (raw) ECC bytes*/ 611 ret = mtd_ooblayout_get_eccbytes(mtd, ecccode, req->oobbuf.in, 0, 612 total); 613 if (ret) 614 return ret; 615 616 /* Calculate the ECC bytes */ 617 for (i = 0; eccsteps; eccsteps--, i += eccbytes, data += eccsize) 618 nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]); 619 620 /* Finish a page read: compare and correct */ 621 for (eccsteps = engine_conf->nsteps, i = 0, data = req->databuf.in; 622 eccsteps; 623 eccsteps--, i += eccbytes, data += eccsize) { 624 int stat = nand_ecc_sw_hamming_correct(nand, data, 625 &ecccode[i], 626 &ecccalc[i]); 627 if (stat < 0) { 628 mtd->ecc_stats.failed++; 629 } else { 630 mtd->ecc_stats.corrected += stat; 631 max_bitflips = max_t(unsigned int, max_bitflips, stat); 632 } 633 } 634 635 nand_ecc_restore_req(&engine_conf->req_ctx, req); 636 637 return max_bitflips; 638 } 639 640 static struct nand_ecc_engine_ops nand_ecc_sw_hamming_engine_ops = { 641 .init_ctx = nand_ecc_sw_hamming_init_ctx, 642 .cleanup_ctx = nand_ecc_sw_hamming_cleanup_ctx, 643 .prepare_io_req = nand_ecc_sw_hamming_prepare_io_req, 644 .finish_io_req = nand_ecc_sw_hamming_finish_io_req, 645 }; 646 647 static struct nand_ecc_engine nand_ecc_sw_hamming_engine = { 648 .ops = &nand_ecc_sw_hamming_engine_ops, 649 }; 650 651 struct nand_ecc_engine *nand_ecc_sw_hamming_get_engine(void) 652 { 653 return &nand_ecc_sw_hamming_engine; 654 } 655 EXPORT_SYMBOL(nand_ecc_sw_hamming_get_engine); 656 657 MODULE_LICENSE("GPL"); 658 MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>"); 659 MODULE_DESCRIPTION("NAND software Hamming ECC support"); 660