drivers/mtd/nand/raw/nand_ecc.c

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