一. ECC校验

ECC: error Checking and correct,既能检查错误也能纠正错误.

优点是: 速度奇快

缺点是: 只能检查2bit的错误,只能纠正1bit的错误

如果想验证这儿需要打开 param . no_tags_ecc=0,默认 param . no_tags_ecc=1不进行tags校验.

同时,mkyaffs2image中也要把ECC校验信息加进去,这样才能从nand_flash中读出ECC进行比较.

nandmtd2_read_chunk_tags

--> yaffs_unpack_tags2

void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, int tags_ecc)

{

enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;

if (pt->t.seq_number != 0xffffffff && tags_ecc) {

struct yaffs_ecc_other ecc;

int result;

yaffs_ecc_calc_other((unsigned char *)&pt->t, sizeof(struct yaffs_packed_tags2_tags_only), &ecc);

result = yaffs_ecc_correct_other((unsigned char *)&pt->t,

sizeof(struct yaffs_packed_tags2_tags_only), &pt->ecc, &ecc);

switch (result) {

case 0:

ecc_result = YAFFS_ECC_RESULT_NO_ERROR;

break;

case 1:

ecc_result = YAFFS_ECC_RESULT_FIXED;

break;

case -1:

ecc_result = YAFFS_ECC_RESULT_UNFIXED;

break;

default:

ecc_result = YAFFS_ECC_RESULT_UNKNOWN;

}

}

yaffs_unpack_tags2_tags_only(t, &pt->t);

t->ecc_result = ecc_result; //保存校验后的结果, 调用它的函数是要检查的

yaffs_dump_packed_tags2(pt); //打印而己,不关心

yaffs_dump_tags2(t); //打印而己,不关心

}

这部分主要是校验yaffs_packed_tags2* pt中的结果, sizeof(yaffs_packed_tags2)=4*7=28

struct yaffs_packed_tags2_tags_only {

unsigned seq_number;

unsigned obj_id;

unsigned chunk_id;

unsigned n_bytes;

};

struct yaffs_ecc_other {

unsigned char col_parity;

unsigned line_parity;

unsigned line_parity_prime;

};

struct yaffs_packed_tags2 {

struct yaffs_packed_tags2_tags_only t;

struct yaffs_ecc_other ecc;

};

注意: 这个校验只被 nandmtd2_read_chunk_tags所调用,因为 pt中的数据是存在nand flash的OOB区的,data区的数据在读取时己经被检验过了.

yaffs把OOB区前28个字节也拿来当数据使用了,所以这部分也需要校验.但是nand_flash只会对data区的数据进行校验,所以需要自己写代码来校验这OOB的28个字节

二.校验算法

2. 生成column_parity_table表

#include

#include

unsigned char entry(unsigned char x)

{

unsigned char b0, b1, b2, b3, b4, b5, b6, b7;

unsigned char p4, p2, p1, p4p, p2p, p1p;

unsigned char linep;

unsigned char result;

b0 = (x & 0x01) ? 1 : 0;

b1 = (x & 0x02) ? 1 : 0;

b2 = (x & 0x04) ? 1 : 0;

b3 = (x & 0x08) ? 1 : 0;

b4 = (x & 0x10) ? 1 : 0;

b5 = (x & 0x20) ? 1 : 0;

b6 = (x & 0x40) ? 1 : 0;

b7 = (x & 0x80) ? 1 : 0;

p4 = b7 ^ b6 ^ b5 ^ b4; p4p = b3 ^ b2 ^ b1 ^ b0;

p2 = b7 ^ b6 ^ b3 ^ b2; p2p = b5 ^ b4 ^ b1 ^ b0;

p1 = b7 ^ b5 ^ b3 ^ b1; p1p = b6 ^ b4 ^ b2 ^ b0;

linep = p1 ^ p1p;

result = 0;

if(p4) result |= 0x80;

if(p4p) result |= 0x40;

if(p2) result |= 0x20;

if(p2p) result |= 0x10;

if(p1) result |= 0x08;

if(p1p) result |= 0x04;

if(linep) result |= 0x01;

//result >>= 2;

//if(linep) result |= 0x40;

return result;

}

int main(int argc, char *argv[])

{

unsigned i;

printf("const unsigned char column_parity_table[] = {");

for(i = 0; i < 256; i++)

{

if((i & 0xf) == 0) printf("n");

printf("0x%02x, ",entry((unsigned char) i));

}

printf("n};n");

}

所以每一个result都是:

2.1校验步骤

a. 通过yaffs_ecc_calc_other生成ECC, 称为new_ecc

b. new_ecc与old_ecc进行异或,如果不一样,则说明出错

c. 类似于二叉树,找到出错位,并进行校正

void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, struct yaffs_ecc_other *ecc_other) //生成新的ECC

{

unsigned int i;

unsigned char col_parity = 0;

unsigned line_parity = 0;

unsigned line_parity_prime = 0;

unsigned char b;

for (i = 0; i < n_bytes; i++) {

b = column_parity_table[*data++];

col_parity ^= b;

if (b & 0x01) {

/* odd number of bits in the byte */

line_parity ^= i;

line_parity_prime ^= ~i;

}

}

ecc_other->col_parity = (col_parity >> 2) & 0x3f;

ecc_other->line_parity = line_parity;

ecc_other->line_parity_prime = line_parity_prime;

}

3.

int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes,

struct yaffs_ecc_other *read_ecc, const struct yaffs_ecc_other *test_ecc)

{ //与test_ecc比较如果不同则进行校正

unsigned char delta_col; /* column parity delta */

unsigned delta_line; /* line parity delta */

unsigned delta_line_prime; /* line parity delta */

unsigned bit;

delta_col = read_ecc->col_parity ^ test_ecc->col_parity;

delta_line = read_ecc->line_parity ^ test_ecc->line_parity;

delta_line_prime = read_ecc->line_parity_prime ^ test_ecc->line_parity_prime;

if ((delta_col | delta_line | delta_line_prime) == 0)

return 0; /* no error */

if (delta_line == ~delta_line_prime && (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) {

bit = 0; //bit <0-7>,代表哪一位出错

if (delta_col & 0x20)

bit |= 0x04;

if (delta_col & 0x08)

bit |= 0x02;

if (delta_col & 0x02)

bit |= 0x01;

if (delta_line >= n_bytes)

return -1;

data[delta_line] ^= (1 << bit); //找到出错的位了,把它反转

return 1; /* corrected */

}

if ((hweight32(delta_line) + hweight32(delta_line_prime) + hweight8(delta_col)) == 1) {

/* Reccoverable error in ecc */

*read_ecc = *test_ecc;

return 1; /* corrected */

}

/* Unrecoverable error */

return -1;

}