关于nand_ecc.c的菜鸟级问题

jn200002

这个文件代码不多

我刚了解到256+3(24bit)再往代码里去就不懂了

1:第1个结构体(里面定义了256个)用来干吗的啊,看不懂...
(再有问题再编辑近来吧~)

请各位大牛谁了解的给点指示吧~给个网址也行~我搜了不少次了,对于nand_ecc就那一篇分析的,还看不懂...

bitmilong

作者：龙林 EMAIL：dragon_hn@sohu.com WEB：www.dragon-2008.com

ECC简介
　　由于NAND Flash的工艺不能保证NAND的Memory Array在其生命周期中保持性能的可靠，因此，在NAND的生产中及使用过程中会产生坏块。为了检测数据的可靠性，在应用NAND Flash的系统中一般都会采用一定的坏区管理策略，而管理坏区的前提是能比较可靠的进行坏区检测。
　　如果操作时序和电路稳定性不存在问题的话，NAND Flash出错的时候一般不会造成整个Block或是Page不能读取或是全部出错，而是整个Page（例如512Bytes）中只有一个或几个bit出错。
　　对数据的校验常用的有奇偶校验、CRC校验等，而在NAND Flash处理中，一般使用一种比较专用的校验——ECC。ECC能纠正单比特错误和检测双比特错误，而且计算速度很快，但对1比特以上的错误无法纠正，对2比特以上的错误不保证能检测。

ECC原理
　　ECC一般每256字节原始数据生成3字节ECC校验数据，这三字节共24比特分成两部分：6比特的列校验和16比特的行校验，多余的两个比特置1，如下图所示：


　　
　　ECC的列校验和生成规则如下图所示：





　　用数学表达式表示为：
　　　　P4=D7(+)D6(+)D5(+)D4　　P4`=D3(+)D2(+)D1(+)D0
　　　　P2=D7(+)D6(+)D3(+)D2　　P2`=D5(+)D4(+)D1(+)D0
　　　　P1=D7(+)D5(+)D3(+)D1　　P1`=D6(+)D4(+)D2(+)D0
　　这里(+)表示“位异或”操作
　　
　　ECC的行校验和生成规则如下图所示：


　　用数学表达式表示为：
　　　　P8 = bit7(+)bit6(+)bit5(+)bit4(+)bit3(+)bit2(+)bit1(+)bit0(+)P8
　　　　……………………………………………………………………………………
　　这里(+)同样表示“位异或”操作
　
　　当往NAND Flash的page中写入数据的时候，每256字节我们生成一个ECC校验和，称之为原ECC校验和，保存到PAGE的OOB（out-of-band）数据区中。
　　当从NAND Flash中读取数据的时候，每256字节我们生成一个ECC校验和，称之为新ECC校验和。
　　校验的时候，根据上述ECC生成原理不难推断：将从OOB区中读出的原ECC校验和新ECC校验和按位异或，若结果为0，则表示不存在错（或是出现了 ECC无法检测的错误）；若3个字节异或结果中存在11个比特位为1，表示存在一个比特错误，且可纠正；若3个字节异或结果中只存在1个比特位为1，表示 OOB区出错；其他情况均表示出现了无法纠正的错误。

ECC算法的实现

1. 　　static const u_char nand_ecc_precalc_table[] =
   
2. 　　{
   
3. 　　　　0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
   
4. 　　　　0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
   
5. 　　　　0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
   
6. 　　　　0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
   
7. 　　　　0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
   
8. 　　　　0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
   
9. 　　　　0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
   
10. 　　　　0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
    
11. 　　　　0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
    
12. 　　　　0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
    
13. 　　　　0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
    
14. 　　　　0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
    
15. 　　　　0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
    
16. 　　　　0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
    
17. 　　　　0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
    
18. 　　　　0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
    
19. 　　};
    
20. 
    
21. 　　//　Creates non-inverted ECC code from line parity
    
22. 　　static void nand_trans_result(u_char reg2, u_char reg3,u_char *ecc_code)
    
23. 　　{
    
24. 　　　　u_char a, b, i, tmp1, tmp2;
    
25. 
    
26. 　　　　/* Initialize variables */
    
27. 　　　　a = b = 0x80;
    
28. 　　　　tmp1 = tmp2 = 0;
    
29. 
    
30. 　　　　/* Calculate first ECC byte */
    
31. 　　　　for (i = 0; i < 4; i++)
    
32. 　　　　{
    
33. 　　　　　　if (reg3 & a)　　　 /* LP15,13,11,9 --> ecc_code[0] */
    
34. 　　　　　　　　tmp1 |= b;
    
35. 　　　　　　b >>= 1;
    
36. 　　　　　　if (reg2 & a)　　　 /* LP14,12,10,8 --> ecc_code[0] */
    
37. 　　　　　　　　tmp1 |= b;
    
38. 　　　　　　b >>= 1;
    
39. 　　　　　　a >>= 1;
    
40. 　　　　}
    
41. 
    
42. 　　　　/* Calculate second ECC byte */
    
43. 　　　　b = 0x80;
    
44. 　　　　for (i = 0; i < 4; i++)
    
45. 　　　　{
    
46. 　　　　　　if (reg3 & a)　　　 /* LP7,5,3,1 --> ecc_code[1] */
    
47. 　　　　　　　　tmp2 |= b;
    
48. 　　　　　　b >>= 1;
    
49. 　　　　　　if (reg2 & a)　　　 /* LP6,4,2,0 --> ecc_code[1] */
    
50. 　　　　　　　　tmp2 |= b;
    
51. 　　　　　　b >>= 1;
    
52. 　　　　　　a >>= 1;
    
53. 　　　　}
    
54. 
    
55. 　　　　/* Store two of the ECC bytes */
    
56. 　　　　ecc_code[0] = tmp1;
    
57. 　　　　ecc_code[1] = tmp2;
    
58. 　　}
    
59. 
    
60. 　　//　Calculate 3 byte ECC code for 256 byte block
    
61. 　　void nand_calculate_ecc (const u_char *dat, u_char *ecc_code)
    
62. 　　{
    
63. 　　　　u_char idx, reg1, reg2, reg3;
    
64. 　　　　int j;
    
65. 
    
66. 　　　　/* Initialize variables */
    
67. 　　　　reg1 = reg2 = reg3 = 0;
    
68. 　　　　ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
    
69. 
    
70. 　　　　/* Build up column parity */
    
71. 　　　　for(j = 0; j < 256; j++)
    
72. 　　　　{
    
73. 
    
74. 　　　　　　/* Get CP0 - CP5 from table */
    
75. 　　　　　　idx = nand_ecc_precalc_table[dat[j]];
    
76. 　　　　　　reg1 ^= (idx & 0x3f);
    
77. 
    
78. 　　　　　　/* All bit XOR = 1 ? */
    
79. 　　　　　　if (idx & 0x40) {
    
80. 　　　　　　　　reg3 ^= (u_char) j;
    
81. 　　　　　　　　reg2 ^= ~((u_char) j);
    
82. 　　　　　　}
    
83. 　　　　}
    
84. 
    
85. 　　　　/* Create non-inverted ECC code from line parity */
    
86. 　　　　nand_trans_result(reg2, reg3, ecc_code);
    
87. 
    
88. 　　　　/* Calculate final ECC code */
    
89. 　　　　ecc_code[0] = ~ecc_code[0];
    
90. 　　　　ecc_code[1] = ~ecc_code[1];
    
91. 　　　　ecc_code[2] = ((~reg1) << 2) | 0x03;
    
92. 　　}
    
93. 
    
94. 　　//　Detect and correct a 1 bit error for 256 byte block
    
95. 　　int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc)
    
96. 　　{
    
97. 　　　　u_char a, b, c, d1, d2, d3, add, bit, i;
    
98. 
    
99. 　　　　/* Do error detection */
    
100. 　　　　d1 = calc_ecc[0] ^ read_ecc[0];
     
101. 　　　　d2 = calc_ecc[1] ^ read_ecc[1];
     
102. 　　　　d3 = calc_ecc[2] ^ read_ecc[2];
     
103. 
     
104. 　　　　if ((d1 | d2 | d3) == 0)
     
105. 　　　　{
     
106. 　　　　　　/* No errors */
     
107. 　　　　　　return 0;
     
108. 　　　　}
     
109. 　　　　else
     
110. 　　　　{
     
111. 　　　　　　a = (d1 ^ (d1 >> 1)) & 0x55;
     
112. 　　　　　　b = (d2 ^ (d2 >> 1)) & 0x55;
     
113. 　　　　　　c = (d3 ^ (d3 >> 1)) & 0x54;
     
114. 
     
115. 　　　　　　/* Found and will correct single bit error in the data */
     
116. 　　　　　　if ((a == 0x55) && (b == 0x55) && (c == 0x54))
     
117. 　　　　　　{
     
118. 　　　　　　　　c = 0x80;
     
119. 　　　　　　　　add = 0;
     
120. 　　　　　　　　a = 0x80;
     
121. 　　　　　　　　for (i=0; i<4; i++)
     
122. 　　　　　　　　{
     
123. 　　　　　　　　　　if (d1 & c)
     
124. 　　　　　　　　　　　　add |= a;
     
125. 　　　　　　　　　　c >>= 2;
     
126. 　　　　　　　　　　a >>= 1;
     
127. 　　　　　　　　}
     
128. 　　　　　　　　c = 0x80;
     
129. 　　　　　　　　for (i=0; i<4; i++)
     
130. 　　　　　　　　{
     
131. 　　　　　　　　　　if (d2 & c)
     
132. 　　　　　　　　　　　　add |= a;
     
133. 　　　　　　　　　　c >>= 2;
     
134. 　　　　　　　　　　a >>= 1;
     
135. 　　　　　　　　}
     
136. 　　　　　　　　bit = 0;
     
137. 　　　　　　　　b = 0x04;
     
138. 　　　　　　　　c = 0x80;
     
139. 　　　　　　　　for (i=0; i<3; i++)
     
140. 　　　　　　　　{
     
141. 　　　　　　　　　　if (d3 & c)
     
142. 　　　　　　　　　　　　bit |= b;
     
143. 　　　　　　　　　　c >>= 2;
     
144. 　　　　　　　　　　b >>= 1;
     
145. 　　　　　　　　}
     
146. 　　　　　　　　b = 0x01;
     
147. 　　　　　　　　a = dat[add];
     
148. 　　　　　　　　a ^= (b << bit);
     
149. 　　　　　　　　dat[add] = a;
     
150. 　　　　　　　　return 1;
     
151. 　　　　　　}
     
152. 　　　　　　else
     
153. 　　　　　　{
     
154. 　　　　　　　　i = 0;
     
155. 　　　　　　　　while (d1)
     
156. 　　　　　　　　{
     
157. 　　　　　　　　　　if (d1 & 0x01)
     
158. 　　　　　　　　　　　　++i;
     
159. 　　　　　　　　　　d1 >>= 1;
     
160. 　　　　　　　　}
     
161. 　　　　　　　　while (d2)
     
162. 　　　　　　　　{
     
163. 　　　　　　　　　　if (d2 & 0x01)
     
164. 　　　　　　　　　　　　++i;
     
165. 　　　　　　　　　　d2 >>= 1;
     
166. 　　　　　　　　}
     
167. 　　　　　　　　while (d3)
     
168. 　　　　　　　　{
     
169. 　　　　　　　　　　if (d3 & 0x01)
     
170. 　　　　　　　　　　　　++i;
     
171. 　　　　　　　　　　d3 >>= 1;
     
172. 　　　　　　　　}
     
173. 　　　　　　　　if (i == 1)
     
174. 　　　　　　　　{
     
175. 　　　　　　　　　　/* ECC Code Error Correction */
     
176. 　　　　　　　　　　read_ecc[0] = calc_ecc[0];
     
177. 　　　　　　　　　　read_ecc[1] = calc_ecc[1];
     
178. 　　　　　　　　　　read_ecc[2] = calc_ecc[2];
     
179. 　　　　　　　　　　return 2;
     
180. 　　　　　　　　}
     
181. 　　　　　　　　else
     
182. 　　　　　　　　{
     
183. 　　　　　　　　　　/* Uncorrectable Error */
     
184. 　　　　　　　　　　return -1;
     
185. 　　　　　　　　}
     
186. 　　　　　　}
     
187. 　　　　}
     
188. 
     
189. 　　　　/* Should never happen */
     
190. 　　　　return -1;
     
191. 　　}

复制代码

[ 本帖最后由 bitmilong 于 2008-6-24 14:56 编辑 ]

jn200002

5555555看到好感动ING~ 这个图我盯了一上午了 看不懂~~(网上好象我就搜出这唯一一篇介绍的详细的文章~为啥代码不注释,,,,,,)


头儿终于不让我干自己的事情了...我的驱动要暂时放放了,得先把这块儿看明白...


这个图我看不明白  MR BIT  这图需要怎么样才能看懂?那下面代码里的第1个256元素的树组干吗的啊~?

[ 本帖最后由 jn200002 于 2008-6-24 14:46 编辑 ]

bitmilong

第一個圖就是那三個字節,P* 及 P*' 表示每一個位起個名字
第二三圖就是列校驗時 P* 及 P*' 是如何計算得來
第四個圖就是行校驗時 P* 及 P*' 是如何計算得來

D*就是第幾位(bit0~7)

jn200002

3Q啦~我再继续看~

图3是列校验,那它把行校验标出来干吗~?没用的吗?

如果说校验的话,如果算出P4 P2 P1及 P4' P2' P1'这6位(NAND控制器在写入时生成)与从flash中读入时比较 那实际P4 P2 P1.. 它们当中是只存了1或者0么?

[ 本帖最后由 jn200002 于 2008-6-24 15:17 编辑 ]

sep

大家都研究得这么深入啊，令我感到很惭愧

bitmilong

原帖由 sep 于 2008-6-24 15:10 发表
大家都研究得这么深入啊，令我感到很惭愧

sep兄,太扯了

這裏都是菜鳥,現在

jn200002

原帖由 sep 于 2008-6-24 15:10 发表
大家都研究得这么深入啊，令我感到很惭愧

还记得当时我在这提第1个问题的时候 你要准备去搞 MIPS了... 我记得我最后一个问题是: MIPS是什么DONGDONG?然后就没信儿了

jn200002

我看明白这图了~ 第4张图画的多余... 第3张不已经都画全了吗...又或者~我还是没能看懂吧...

哈哈 多谢 MR.BIT  那个256的数组用来干吗呢~?

sep

原帖由 jn200002 于 2008-6-24 15:19 发表


还记得当时我在这提第1个问题的时候 你要准备去搞 MIPS了... 我记得我最后一个问题是: MIPS是什么DONGDONG?然后就没信儿了

哎。其实根本不想搞什么劳什子MIPS，但是项目是要用MIPS体系的cpu
因为对于MIPS体系不熟悉，看提供过来的SDK包里的源码，很多地方很难想得通，具体可以看我的悬赏帖
这扯的太远了，当友情一下