nand_read_page_hwecc与nand_write_page_hwecc

static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                uint8_t *buf, int oob_required, int page)
{
    int i, eccsize = chip->ecc.size;
    int eccbytes = chip->ecc.bytes;
    int eccsteps = chip->ecc.steps;
    uint8_t *p = buf;
    uint8_t *ecc_calc = chip->buffers->ecccalc;
    uint8_t *ecc_code = chip->buffers->ecccode;
    uint32_t *eccpos = chip->ecc.layout->eccpos;

    for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
        chip->ecc.hwctl(mtd, NAND_ECC_READ);
        chip->read_buf(mtd, p, eccsize);
        chip->ecc.calculate(mtd, p, &ecc_calc[i]);//每512字节，读出硬件ecc字节，存放到ecc_calc，例如8bitecc，每次读取13字节，i+=13，循环4次
    }
    chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);

    for (i = 0; i < chip->ecc.total; i++)
        ecc_code[i] = chip->oob_poi[eccpos[i]];//读出OOB区域的ecc数据，存放到ecc_code，例如8bitecc，读取13*4=52字节

    eccsteps = chip->ecc.steps;
    p = buf;

    for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
        int stat;

        stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);//8bitecc是通过硬件完成的，所以校验函数应该放这里，而是每次写512字节时就进行校验
        if (stat < 0)
            mtd->ecc_stats.failed++;
        else
            mtd->ecc_stats.corrected += stat;
    }
    return 0;
}

/**
 * nand_write_page_hwecc - [REPLACEABLE] hardware ECC based page write function
 * @mtd: mtd info structure
 * @chip: nand chip info structure
 * @buf: data buffer
 * @oob_required: must write chip->oob_poi to OOB
 */
static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
                 const uint8_t *buf, int oob_required)
{
    int i, eccsize = chip->ecc.size;
    int eccbytes = chip->ecc.bytes;
    int eccsteps = chip->ecc.steps;
    uint8_t *ecc_calc = chip->buffers->ecccalc;
    const uint8_t *p = buf;
    uint32_t *eccpos = chip->ecc.layout->eccpos;

    for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
        chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
        chip->write_buf(mtd, p, eccsize);
        chip->ecc.calculate(mtd, p, &ecc_calc[i]);
    }

    for (i = 0; i < chip->ecc.total; i++)
        chip->oob_poi[eccpos[i]] = ecc_calc[i];

    chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);

    return 0;
}

/**
 * nand_bch_correct_data - [NAND Interface] Detect and correct bit error(s)
 * @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 bit errors for a data byte block
 */
int nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf,
              unsigned char *read_ecc, unsigned char *calc_ecc)
{
    const struct nand_chip *chip = mtd->priv;
    struct nand_bch_control *nbc = chip->ecc.priv;
    unsigned int *errloc = nbc->errloc;
    int i, count;

    count = decode_bch(nbc->bch, NULL, chip->ecc.size, read_ecc, calc_ecc,
             NULL, errloc);
    if (count > 0) {
        for (i = 0; i < count; i++) {
            if (errloc[i] < (chip->ecc.size*8))
                /* error is located in data, correct it */
                buf[errloc[i] >> 3] ^= (1 << (errloc[i] & 7));
            /* else error in ecc, no action needed */

            MTDDEBUG(MTD_DEBUG_LEVEL0, "%s: corrected bitflip %u\n",
                  __func__, errloc[i]);
        }
    } else if (count < 0) {
        printk(KERN_ERR "ecc unrecoverable error\n");
        count = -1;
    }
    return count;
}

/**
 * nand_correct_data - [NAND Interface] Detect and correct bit error(s)
 * @mtd:    MTD block structure
 * @dat:    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
 */
int nand_correct_data(struct mtd_info *mtd, u_char *dat,
              u_char *read_ecc, u_char *calc_ecc)
{
    uint8_t s0, s1, s2;

#ifdef CONFIG_MTD_NAND_ECC_SMC
    s0 = calc_ecc[0] ^ read_ecc[0];
    s1 = calc_ecc[1] ^ read_ecc[1];
    s2 = calc_ecc[2] ^ read_ecc[2];
#else
    s1 = calc_ecc[0] ^ read_ecc[0];
    s0 = calc_ecc[1] ^ read_ecc[1];
    s2 = calc_ecc[2] ^ read_ecc[2];
#endif
    if ((s0 | s1 | s2) == 0)
        return 0;

    /* Check for a single bit error */
    if( ((s0 ^ (s0 >> 1)) & 0x55) == 0x55 &&
     ((s1 ^ (s1 >> 1)) & 0x55) == 0x55 &&
     ((s2 ^ (s2 >> 1)) & 0x54) == 0x54) {

        uint32_t byteoffs, bitnum;

        byteoffs = (s1 << 0) & 0x80;
        byteoffs |= (s1 << 1) & 0x40;
        byteoffs |= (s1 << 2) & 0x20;
        byteoffs |= (s1 << 3) & 0x10;

        byteoffs |= (s0 >> 4) & 0x08;
        byteoffs |= (s0 >> 3) & 0x04;
        byteoffs |= (s0 >> 2) & 0x02;
        byteoffs |= (s0 >> 1) & 0x01;

        bitnum = (s2 >> 5) & 0x04;
        bitnum |= (s2 >> 4) & 0x02;
        bitnum |= (s2 >> 3) & 0x01;

        dat[byteoffs] ^= (1 << bitnum);

        return 1;
    }

    if(countbits(s0 | ((uint32_t)s1 << 8) | ((uint32_t)s2 <<16)) == 1)
        return 1;

    return -EBADMSG;
}