1/* 2 * This file contains an ECC algorithm that detects and corrects 1 bit 3 * errors in a 256 byte block of data. 4 * 5 * drivers/mtd/nand/nand_ecc.c 6 * 7 * Copyright �� 2008 Koninklijke Philips Electronics NV. 8 * Author: Frans Meulenbroeks 9 * 10 * Completely replaces the previous ECC implementation which was written by: 11 * Steven J. Hill (sjhill@realitydiluted.com) 12 * Thomas Gleixner (tglx@linutronix.de) 13 * 14 * Information on how this algorithm works and how it was developed 15 * can be found in Documentation/mtd/nand_ecc.txt 16 * 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 20 * later version. 21 * 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 25 * for more details. 26 * 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. 30 * 31 */ 32 33/* 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) 40 */ 41#ifndef STANDALONE 42#include <linux/types.h> 43#include <linux/kernel.h> 44#include <linux/module.h> 45#include <linux/mtd/mtd.h> 46#include <linux/mtd/nand.h> 47#include <linux/mtd/nand_ecc.h> 48#include <asm/byteorder.h> 49#else 50#include <stdint.h> 51struct mtd_info; 52#define EXPORT_SYMBOL(x) /* x */ 53 54#define MODULE_LICENSE(x) /* x */ 55#define MODULE_AUTHOR(x) /* x */ 56#define MODULE_DESCRIPTION(x) /* x */ 57 58#define printk printf 59#define KERN_ERR "" 60#endif 61 62/* 63 * invparity is a 256 byte table that contains the odd parity 64 * for each byte. So if the number of bits in a byte is even, 65 * the array element is 1, and when the number of bits is odd 66 * the array eleemnt is 0. 67 */ 68static const char invparity[256] = { 69 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 70 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 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 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 74 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 75 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 76 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 77 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 78 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 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 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 82 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 83 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 84 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1 85}; 86 87/* 88 * bitsperbyte contains the number of bits per byte 89 * this is only used for testing and repairing parity 90 * (a precalculated value slightly improves performance) 91 */ 92static const char bitsperbyte[256] = { 93 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 94 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 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 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 98 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 99 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 100 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 101 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 102 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 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 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 106 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 107 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 108 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, 109}; 110 111/* 112 * addressbits is a lookup table to filter out the bits from the xor-ed 113 * ecc data that identify the faulty location. 114 * this is only used for repairing parity 115 * see the comments in nand_correct_data for more details 116 */ 117static const char addressbits[256] = { 118 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 119 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 120 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 121 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 122 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 123 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 124 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 125 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 126 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 127 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 128 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 129 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 130 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 131 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 132 0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05, 133 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07, 134 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 135 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 136 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 137 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 138 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 139 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 140 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 141 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 142 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 143 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 144 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09, 145 0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b, 146 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 147 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 148 0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 149 0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f 150}; 151 152/** 153 * __nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte 154 * block 155 * @buf: input buffer with raw data 156 * @eccsize: data bytes per ecc step (256 or 512) 157 * @code: output buffer with ECC 158 */ 159void __nand_calculate_ecc(const unsigned char *buf, unsigned int eccsize, 160 unsigned char *code) 161{ 162 int i; 163 const uint32_t *bp = (uint32_t *)buf; 164 /* 256 or 512 bytes/ecc */ 165 const uint32_t eccsize_mult = eccsize >> 8; 166 uint32_t cur; /* current value in buffer */ 167 /* rp0..rp15..rp17 are the various accumulated parities (per byte) */ 168 uint32_t rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7; 169 uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15, rp16; 170 uint32_t uninitialized_var(rp17); /* to make compiler happy */ 171 uint32_t par; /* the cumulative parity for all data */ 172 uint32_t tmppar; /* the cumulative parity for this iteration; 173 for rp12, rp14 and rp16 at the end of the 174 loop */ 175 176 par = 0; 177 rp4 = 0; 178 rp6 = 0; 179 rp8 = 0; 180 rp10 = 0; 181 rp12 = 0; 182 rp14 = 0; 183 rp16 = 0; 184 185 /* 186 * The loop is unrolled a number of times; 187 * This avoids if statements to decide on which rp value to update 188 * Also we process the data by longwords. 189 * Note: passing unaligned data might give a performance penalty. 190 * It is assumed that the buffers are aligned. 191 * tmppar is the cumulative sum of this iteration. 192 * needed for calculating rp12, rp14, rp16 and par 193 * also used as a performance improvement for rp6, rp8 and rp10 194 */ 195 for (i = 0; i < eccsize_mult << 2; i++) { 196 cur = *bp++; 197 tmppar = cur; 198 rp4 ^= cur; 199 cur = *bp++; 200 tmppar ^= cur; 201 rp6 ^= tmppar; 202 cur = *bp++; 203 tmppar ^= cur; 204 rp4 ^= cur; 205 cur = *bp++; 206 tmppar ^= cur; 207 rp8 ^= tmppar; 208 209 cur = *bp++; 210 tmppar ^= cur; 211 rp4 ^= cur; 212 rp6 ^= cur; 213 cur = *bp++; 214 tmppar ^= cur; 215 rp6 ^= cur; 216 cur = *bp++; 217 tmppar ^= cur; 218 rp4 ^= cur; 219 cur = *bp++; 220 tmppar ^= cur; 221 rp10 ^= tmppar; 222 223 cur = *bp++; 224 tmppar ^= cur; 225 rp4 ^= cur; 226 rp6 ^= cur; 227 rp8 ^= cur; 228 cur = *bp++; 229 tmppar ^= cur; 230 rp6 ^= cur; 231 rp8 ^= cur; 232 cur = *bp++; 233 tmppar ^= cur; 234 rp4 ^= cur; 235 rp8 ^= cur; 236 cur = *bp++; 237 tmppar ^= cur; 238 rp8 ^= cur; 239 240 cur = *bp++; 241 tmppar ^= cur; 242 rp4 ^= cur; 243 rp6 ^= cur; 244 cur = *bp++; 245 tmppar ^= cur; 246 rp6 ^= cur; 247 cur = *bp++; 248 tmppar ^= cur; 249 rp4 ^= cur; 250 cur = *bp++; 251 tmppar ^= cur; 252 253 par ^= tmppar; 254 if ((i & 0x1) == 0) 255 rp12 ^= tmppar; 256 if ((i & 0x2) == 0) 257 rp14 ^= tmppar; 258 if (eccsize_mult == 2 && (i & 0x4) == 0) 259 rp16 ^= tmppar; 260 } 261 262 /* 263 * handle the fact that we use longword operations 264 * we'll bring rp4..rp14..rp16 back to single byte entities by 265 * shifting and xoring first fold the upper and lower 16 bits, 266 * then the upper and lower 8 bits. 267 */ 268 rp4 ^= (rp4 >> 16); 269 rp4 ^= (rp4 >> 8); 270 rp4 &= 0xff; 271 rp6 ^= (rp6 >> 16); 272 rp6 ^= (rp6 >> 8); 273 rp6 &= 0xff; 274 rp8 ^= (rp8 >> 16); 275 rp8 ^= (rp8 >> 8); 276 rp8 &= 0xff; 277 rp10 ^= (rp10 >> 16); 278 rp10 ^= (rp10 >> 8); 279 rp10 &= 0xff; 280 rp12 ^= (rp12 >> 16); 281 rp12 ^= (rp12 >> 8); 282 rp12 &= 0xff; 283 rp14 ^= (rp14 >> 16); 284 rp14 ^= (rp14 >> 8); 285 rp14 &= 0xff; 286 if (eccsize_mult == 2) { 287 rp16 ^= (rp16 >> 16); 288 rp16 ^= (rp16 >> 8); 289 rp16 &= 0xff; 290 } 291 292 /* 293 * we also need to calculate the row parity for rp0..rp3 294 * This is present in par, because par is now 295 * rp3 rp3 rp2 rp2 in little endian and 296 * rp2 rp2 rp3 rp3 in big endian 297 * as well as 298 * rp1 rp0 rp1 rp0 in little endian and 299 * rp0 rp1 rp0 rp1 in big endian 300 * First calculate rp2 and rp3 301 */ 302#ifdef __BIG_ENDIAN 303 rp2 = (par >> 16); 304 rp2 ^= (rp2 >> 8); 305 rp2 &= 0xff; 306 rp3 = par & 0xffff; 307 rp3 ^= (rp3 >> 8); 308 rp3 &= 0xff; 309#else 310 rp3 = (par >> 16); 311 rp3 ^= (rp3 >> 8); 312 rp3 &= 0xff; 313 rp2 = par & 0xffff; 314 rp2 ^= (rp2 >> 8); 315 rp2 &= 0xff; 316#endif 317 318 /* reduce par to 16 bits then calculate rp1 and rp0 */ 319 par ^= (par >> 16); 320#ifdef __BIG_ENDIAN 321 rp0 = (par >> 8) & 0xff; 322 rp1 = (par & 0xff); 323#else 324 rp1 = (par >> 8) & 0xff; 325 rp0 = (par & 0xff); 326#endif 327 328 /* finally reduce par to 8 bits */ 329 par ^= (par >> 8); 330 par &= 0xff; 331 332 /* 333 * and calculate rp5..rp15..rp17 334 * note that par = rp4 ^ rp5 and due to the commutative property 335 * of the ^ operator we can say: 336 * rp5 = (par ^ rp4); 337 * The & 0xff seems superfluous, but benchmarking learned that 338 * leaving it out gives slightly worse results. No idea why, probably 339 * it has to do with the way the pipeline in pentium is organized. 340 */ 341 rp5 = (par ^ rp4) & 0xff; 342 rp7 = (par ^ rp6) & 0xff; 343 rp9 = (par ^ rp8) & 0xff; 344 rp11 = (par ^ rp10) & 0xff; 345 rp13 = (par ^ rp12) & 0xff; 346 rp15 = (par ^ rp14) & 0xff; 347 if (eccsize_mult == 2) 348 rp17 = (par ^ rp16) & 0xff; 349 350 /* 351 * Finally calculate the ecc bits. 352 * Again here it might seem that there are performance optimisations 353 * possible, but benchmarks showed that on the system this is developed 354 * the code below is the fastest 355 */ 356#ifdef CONFIG_MTD_NAND_ECC_SMC 357 code[0] = 358 (invparity[rp7] << 7) | 359 (invparity[rp6] << 6) | 360 (invparity[rp5] << 5) | 361 (invparity[rp4] << 4) | 362 (invparity[rp3] << 3) | 363 (invparity[rp2] << 2) | 364 (invparity[rp1] << 1) | 365 (invparity[rp0]); 366 code[1] = 367 (invparity[rp15] << 7) | 368 (invparity[rp14] << 6) | 369 (invparity[rp13] << 5) | 370 (invparity[rp12] << 4) | 371 (invparity[rp11] << 3) | 372 (invparity[rp10] << 2) | 373 (invparity[rp9] << 1) | 374 (invparity[rp8]); 375#else 376 code[1] = 377 (invparity[rp7] << 7) | 378 (invparity[rp6] << 6) | 379 (invparity[rp5] << 5) | 380 (invparity[rp4] << 4) | 381 (invparity[rp3] << 3) | 382 (invparity[rp2] << 2) | 383 (invparity[rp1] << 1) | 384 (invparity[rp0]); 385 code[0] = 386 (invparity[rp15] << 7) | 387 (invparity[rp14] << 6) | 388 (invparity[rp13] << 5) | 389 (invparity[rp12] << 4) | 390 (invparity[rp11] << 3) | 391 (invparity[rp10] << 2) | 392 (invparity[rp9] << 1) | 393 (invparity[rp8]); 394#endif 395 if (eccsize_mult == 1) 396 code[2] = 397 (invparity[par & 0xf0] << 7) | 398 (invparity[par & 0x0f] << 6) | 399 (invparity[par & 0xcc] << 5) | 400 (invparity[par & 0x33] << 4) | 401 (invparity[par & 0xaa] << 3) | 402 (invparity[par & 0x55] << 2) | 403 3; 404 else 405 code[2] = 406 (invparity[par & 0xf0] << 7) | 407 (invparity[par & 0x0f] << 6) | 408 (invparity[par & 0xcc] << 5) | 409 (invparity[par & 0x33] << 4) | 410 (invparity[par & 0xaa] << 3) | 411 (invparity[par & 0x55] << 2) | 412 (invparity[rp17] << 1) | 413 (invparity[rp16] << 0); 414} 415EXPORT_SYMBOL(__nand_calculate_ecc); 416 417/** 418 * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte 419 * block 420 * @mtd: MTD block structure 421 * @buf: input buffer with raw data 422 * @code: output buffer with ECC 423 */ 424int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf, 425 unsigned char *code) 426{ 427 __nand_calculate_ecc(buf, 428 ((struct nand_chip *)mtd->priv)->ecc.size, code); 429 430 return 0; 431} 432EXPORT_SYMBOL(nand_calculate_ecc); 433 434/** 435 * __nand_correct_data - [NAND Interface] Detect and correct bit error(s) 436 * @buf: raw data read from the chip 437 * @read_ecc: ECC from the chip 438 * @calc_ecc: the ECC calculated from raw data 439 * @eccsize: data bytes per ecc step (256 or 512) 440 * 441 * Detect and correct a 1 bit error for eccsize byte block 442 */ 443int __nand_correct_data(unsigned char *buf, 444 unsigned char *read_ecc, unsigned char *calc_ecc, 445 unsigned int eccsize) 446{ 447 unsigned char b0, b1, b2, bit_addr; 448 unsigned int byte_addr; 449 /* 256 or 512 bytes/ecc */ 450 const uint32_t eccsize_mult = eccsize >> 8; 451 452 /* 453 * b0 to b2 indicate which bit is faulty (if any) 454 * we might need the xor result more than once, 455 * so keep them in a local var 456 */ 457#ifdef CONFIG_MTD_NAND_ECC_SMC 458 b0 = read_ecc[0] ^ calc_ecc[0]; 459 b1 = read_ecc[1] ^ calc_ecc[1]; 460#else 461 b0 = read_ecc[1] ^ calc_ecc[1]; 462 b1 = read_ecc[0] ^ calc_ecc[0]; 463#endif 464 b2 = read_ecc[2] ^ calc_ecc[2]; 465 466 /* check if there are any bitfaults */ 467 468 /* repeated if statements are slightly more efficient than switch ... */ 469 /* ordered in order of likelihood */ 470 471 if ((b0 | b1 | b2) == 0) 472 return 0; /* no error */ 473 474 if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) && 475 (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) && 476 ((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) || 477 (eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) { 478 /* single bit error */ 479 /* 480 * rp17/rp15/13/11/9/7/5/3/1 indicate which byte is the faulty 481 * byte, cp 5/3/1 indicate the faulty bit. 482 * A lookup table (called addressbits) is used to filter 483 * the bits from the byte they are in. 484 * A marginal optimisation is possible by having three 485 * different lookup tables. 486 * One as we have now (for b0), one for b2 487 * (that would avoid the >> 1), and one for b1 (with all values 488 * << 4). However it was felt that introducing two more tables 489 * hardly justify the gain. 490 * 491 * The b2 shift is there to get rid of the lowest two bits. 492 * We could also do addressbits[b2] >> 1 but for the 493 * performance it does not make any difference 494 */ 495 if (eccsize_mult == 1) 496 byte_addr = (addressbits[b1] << 4) + addressbits[b0]; 497 else 498 byte_addr = (addressbits[b2 & 0x3] << 8) + 499 (addressbits[b1] << 4) + addressbits[b0]; 500 bit_addr = addressbits[b2 >> 2]; 501 /* flip the bit */ 502 buf[byte_addr] ^= (1 << bit_addr); 503 return 1; 504 505 } 506 /* count nr of bits; use table lookup, faster than calculating it */ 507 if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1) 508 return 1; /* error in ecc data; no action needed */ 509 510 printk(KERN_ERR "uncorrectable error : "); 511 return -1; 512} 513EXPORT_SYMBOL(__nand_correct_data); 514 515/** 516 * nand_correct_data - [NAND Interface] Detect and correct bit error(s) 517 * @mtd: MTD block structure 518 * @buf: raw data read from the chip 519 * @read_ecc: ECC from the chip 520 * @calc_ecc: the ECC calculated from raw data 521 * 522 * Detect and correct a 1 bit error for 256/512 byte block 523 */ 524int nand_correct_data(struct mtd_info *mtd, unsigned char *buf, 525 unsigned char *read_ecc, unsigned char *calc_ecc) 526{ 527 return __nand_correct_data(buf, read_ecc, calc_ecc, 528 ((struct nand_chip *)mtd->priv)->ecc.size); 529} 530EXPORT_SYMBOL(nand_correct_data); 531 532MODULE_LICENSE("GPL"); 533MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>"); 534MODULE_DESCRIPTION("Generic NAND ECC support"); 535