S5PV210裸机开发笔记--nand ecc

这里补充一下nand flash行列地址的知识：

行地址就是页地址，列地址是指页内偏移地址。spare就是指OOB区域。在一个页内部，数据区域和OOB区域是连续的，如果不需要ECC校验，一般不使用OOB区域。对读写操作来讲，数据和OOB的编程方法上是相同的。
一般说2k页的nand flash，其实省略掉了64字节的OOB。2K+64 ，需要12位二进制来表示，但是对于页内偏移（即列地址），大于2112的地址是无效的，虽然列地址有12位,，因为2048+64=2112。
谁说读4096能读出来，要读OOB，列地址指定2048开始读64个字节就好了。


main函数：

int main()
{
    int i, ret;
    u8 oob[64];
    u8 buf[2048];

    bzero(buf, 2048);
    mdelay(5000);
    printf("erasing...\n");
    mdelay(1000);
    while(1)
    {
        printf("helloword\n");
        mdelay(500);
    }
    /* 1.擦除第0块 */
    nand_erase(0x4000000);

    for (i = 0; i < 2048; i++)
        buf[i] = 0xAA;
    mdelay(1000);
    printf("begin write data\n");
    /*
    ** 2.写入1页数据到0地址(正确数据，全部为0xAA)
    ** 同时将计算出的ECC校验码保存到oob中
    */
    nand_select_chip();
    nand_write_page_8bit(buf, 0x4000000, oob);
    mdelay(1000);
    /* 3.擦除第0块 */
    nand_erase(0x4000000);
    mdelay(1000);
    /*
    ** 4.将前8个数据的第0位取反(0xAB)，不使用应硬件ECC，将1页数据写入第0页
    ** 同时将上面记录下的ECC写入spare区
    */
    for (i = 0; i < 8; i++)
        buf[i] ^= 0x01;

    nand_select_chip();
    nand_write_page(buf, 0x4000000, oob);

    bzero(buf, 2048);

    /* 5.使用三星提供的8位硬件ECC校验拷贝函数读取一页数据 */
    //ret = NF8_ReadPage_8ECC(0, buf);
    ret = nand_read_page_8bit(buf, 0x4000000);

    nand_deselect_chip();

    printf("\nret = %d\n", ret);
    /* 打印第一个数据 */
    for (i = 0; i < 10; i++)
        printf("%X ", buf[i]);
    return 0;
}

读写函数：

/* 写一页数据 */
void nand_write_page(u8 *buf, u32 addr, u8 *oob)
{
    if (addr & (PAGE_SIZE - 1))
    {
        printf("not page align\n");
        return;
    }

    nand_cmd(0x80);
    nand_addr(addr);
    nand_wait_ready();

    nand_write_buf(buf, PAGE_SIZE);

    nand_write_buf(oob, 64);

    nand_cmd(0x10);
    nand_wait_ready();
}

/* 写一页数据，同时将Ecc Code写入OOB区 */
void nand_write_page_8bit(u8 *buf, u32 addr, u8 *oob)
{
    if (addr & (PAGE_SIZE - 1))
    {
        printf("not page align\n");
        return;
    }

    nand_cmd(0x80);
    nand_addr(addr);
    nand_wait_ready();

    int i;
    int eccsize = 512;
    int eccbytes = 13;
    int eccsteps = PAGE_SIZE / eccsize;
    int ecctotal = eccsteps * eccbytes;

    for (i = 0; i < 12; i++)
        oob[i] = 0xFF;

    /* 每次写eccsize个字节，分eccsteps次写完一页数据 */
    for (i = 0; eccsteps; eccsteps--, i += eccbytes, buf += eccsize)
    {
        nand_init_hwecc_8bit(WRITE_ECC);                    /* 初始化ECC写 */
        nand_write_buf(buf, eccsize);
        nand_calculate_ecc_8bit(oob + i + 12, WRITE_ECC);    /* 计算ECC校验码，  实际上是读取4个ecc寄存器，得到13字节ecc */
    }

    nand_write_buf(oob, 64);                    /* 将计算出的ECC写入OOB */

#if 1
    printf("--------write Ecc---------\n");
    for (i = 0; i < 64; i++)
    {
        if (i % 8 == 0)
            putchar('\n');
        printf("%X ", oob[i]);
    }
    putchar('\n');
#endif

    nand_cmd(0x10);
    nand_wait_ready();
}

int nand_read_page_8bit(u8 *buf, u32 addr)
{
    int err = 0;
    if (addr & (PAGE_SIZE - 1))
    {
        printf("not page align\n");
        return;
    }

    u8 oob[64];
    nand_read_oob(oob, addr, 64);

    int i;
#if 1
    printf("--------read Ecc---------\n");
    for (i = 0; i < 64; i++)
    {
        if (i % 8 == 0)
            putchar('\n');
        printf("%X ", oob[i]);
    }
    putchar('\n');
#endif

    nand_cmd(0);
    nand_addr(addr);
    nand_cmd(0x30);
    nand_wait_ready();

    int col;
    int eccsize = 512;
    int eccbytes = 13;
    int eccsteps = PAGE_SIZE / eccsize;
    int ecctotal = eccsteps * eccbytes;

    /* 每次写eccsize个字节，分eccsteps次写完一页数据 */
    for (i = 0, col = 0; eccsteps; eccsteps--, i += eccbytes, buf += eccsize, col += eccsize)
    {
        /* 页内偏移 */
        nand_cmd(0x05);
        NFADDR = col & 0xFF;
        NFADDR = (col >> 8) & 0xF;
        nand_cmd(0xE0);

        nand_init_hwecc_8bit(READ_ECC);            /* 初始化ECC读 */
        nand_read_buf(buf, eccsize);
        /* 下面两种方式都可以 */
#if 0
        nand_cmd(0x05);
        NFADDR = (2048 + i + 12)& 0xFF;
        NFADDR = ((2048 + i + 12) >> 8) & 0xF;
        nand_cmd(0xE0);
        nand_read_buf(oob, eccbytes);/* 每读512字节数据读取13字节的oob ，需要重新发送地址，不推荐*/
#else
        nand_write_buf(oob + 12 + i, eccbytes);/* 写入13B ecc ，推荐这种方法，只需要在读数据之前预先读取52B ecc检验码 */
#endif

        nand_calculate_ecc_8bit(0, READ_ECC);    /* 计算ECC校验码，实际上只需要等待NFECCSTAT标志位 */
        if (nand_correct_data_8bit(buf) < 0)
            err++;
    }

    return err;
}

/*
** 三星提供的固化在iROM里的函数
** 使用8位硬件ECC读取1页数据
** 成功返回0，否则返回1
*/
int NF8_ReadPage_8ECC(u32 addr, u8 *buf)
{
    if (addr & (PAGE_SIZE - 1))
    {
        printf("not page align\n");
        return;
    }

    int page = addr / PAGE_SIZE;
    int ret = NF8_ReadPage_Adv(page / PAGE_PER_BLK, page % PAGE_PER_BLK, buf);
    return ret;
}

关键是nand_init_hwecc_8bit和nand_calculate_ecc_8bit这两个函数，nand每次读写都需要init_hw_ecc，
nand ecc步骤分为4步：init hw ecc->write buf->calc ecc->write oob
1.  init hw ecc
2.  write buf或者read buf
3.  calc ecc
4.  重复1~3，重复次数为eccstep = pagesize/eccsize= 2048/512=4，每512字节生成13字节ecc。凑齐4份ecc（52B）
5.  write oob（52B）

5pv210实现带ecc方式读函数有2种做法，一种是每读512字节立即读13bytes ECC，这种办法有个缺点就是每页数据（2048B）需要发送4次地址。
另一种做法是先读取52B的ECC数据，再分4次读页数据，每读512B，将之前读到13字节ecc写入，让ecc模块搜索错误位。


计算ecc是硬件完成的，只需要读取4个ecc寄存器就能得到ecc检验码：
/* 读取13 Byte的Ecc Code ，每个寄存器4个字节，需要用4个寄存器存储*/
nfeccprgecc0 = NFECCPRGECC0;
nfeccprgecc1 = NFECCPRGECC1;
nfeccprgecc2 = NFECCPRGECC2;
nfeccprgecc3 = NFECCPRGECC3;
得到ecc之后，需要手动写入OOB区域。

检验数据用nand_correct_data_8bit函数

int nand_correct_data_8bit(u8 *dat)
{
    int ret = 0;
    u32 errNo;
    u32 erl0, erl1, erl2, erl3, erp0, erp1;

    /* Wait until the 8-bit ECC decoding engine is Idle */
    while (NFECCSTAT & (1 << 31));

    errNo = NFECCSECSTAT & 0x1F;
    erl0 = NFECCERL0;
    erl1 = NFECCERL1;
    erl2 = NFECCERL2;
    erl3 = NFECCERL3;

    erp0 = NFECCERP0;
    erp1 = NFECCERP1;

    if (errNo)
        printf("errNo = %d\n", errNo);

    switch (errNo)
    {
    case 8:
        dat[(erl3 >> 16) & 0x3FF] ^= (erp1 >> 24) & 0xFF;
    case 7:
        dat[erl3 & 0x3FF] ^= (erp1 >> 16) & 0xFF;
    case 6:
        dat[(erl2 >> 16) & 0x3FF] ^= (erp1 >> 8) & 0xFF;
    case 5:
        dat[erl2 & 0x3FF] ^= erp1 & 0xFF;
    case 4:
        dat[(erl1 >> 16) & 0x3FF] ^= (erp0 >> 24) & 0xFF;
    case 3:
        dat[erl1 & 0x3FF] ^= (erp0 >> 16) & 0xFF;
    case 2:
        dat[(erl0 >> 16) & 0x3FF] ^= (erp0 >> 8) & 0xFF;
    case 1:
        dat[erl0 & 0x3FF] ^= erp0 & 0xFF;
    case 0:
        break;
    default:
        ret = -1;
        printf("ECC uncorrectable error detected\n");
        break;
    }

    return ret;
}

内容很简单，芯片手册说明了。
参考：

4.3.10 8/12/16-BIT ECC PROGRAMMING GUIDE (DECODING)
1. To use 8/ 12/ 16-bit ECC in software mode, set the MsgLength(NFECCCONF[25:16] to 511(512-byte
message length) and the ECCType to “001/100/101”(enable 8/12/16-bit ECC, respectively). ECC module
generates ECC parity code for 512-byte read data. Therefore, you must reset ECC value by writing the
InitMECC (NFECCCONT[2]) bit as ‘1’, and clear the MainECCLock(NFCONT[7]) bit to ‘0’(Unlock) before read
data.
2. Whenever data is read, the 8/12/16-bit ECC module generates ECC parity code internally.
3. After you complete reading 512-byte (not including spare area data), ensure to read the corresponding parity
codes. ECC module needs parity codes to detect whether error bits have occurred or not. Therefore, you have
to read ECC parity code immediately after reading 512-byte. After ECC parity code is read, the 8/12/16-bit
ECC engine searches for error internally. 8/12/16-bit ECC search engine needs minimum of 155 cycles to find
any errors. DecodeDone(NFECCSTAT[24]) can be used to check whether ECC decoding is completed or not.
4. When DecodeDone (NFECCSTAT[24]) is set (‘1’), ECCError(NFECCSECSTAT[4:0]) indicates whether error
bit exists or not. If any error exists, you can fix it by referencing NFECCERL0~NFECCERL7 and NFECCERP0
~ NFECCERP3 registers.
5. If you have additional main data to read, continue the steps 1 ~ 4.
6. To check spare area data (meta data) error, the sequences are same (steps 1 ~ 4), except setting the
MsgLenght(NFECCCONF[25:16]) to the size that you want.
NOTE: You should set the ECC parity conversion codes to check free page error. For more information, refer to
refer to 4.3.11 .


关键是第4步，只需要以下寄存器：
NFECCERL0~NFECCERL7 and NFECCERP0
~ NFECCERP3
每个ERL指明2个错误bit的位置，每个ERP包含错误4个错误bit的pattern。所以对于8bit ecc只需要4个ERL，2个ERP。
根据errNo = NFECCSECSTAT & 0x1F 得知有多少个bit错误（最多8个）；
然后对这些错误位重新赋值，data[erl] ^= erp & 0xFF;   //异或运算就是相同为0，不同为1。

实际上，ecc校验码在oob中的位置，可以由编程人员自己定义，但是如果要使用三星提供的NF8_ReadPage_Adv函数，
就必须按照S5PV210_iROM_ApplicationNote_Preliminary_20091126  的规定从OOB[12]开始。因为nand启动时，是8bit ecc方式读取spl的，所以ecc位置也就必须三星的规定了（从oob[12]开始）。但是u-boot运行起来之后，我们就可以更改ecc的位置了，说这些只是想找出yaffs使用硬件ecc的解决办法，因为yaffs 的tag是占用oob空间的，一般只能使用yaffs自己的ecc检验方法，也就是软件ecc，令人很不爽啊。目前只知道am335平台上，yafffs可以使用1bit硬件ecc。


参考：
这篇是1bit 和4bit的文章：
Uboot分析报告
http://blog.sina.com.cn/s/blog_5f9859ee0101irdy.html
这里是标记坏块的文章：
s3c2440对nandflash的操作-
http://blog.chinaunix.net/uid-26023319-id-1743703.html