1. bbt坏块管理
2. 日月 发表于 - 2010-3-2 9:59:00
3. 2
4. 推荐
5. 前面看到在nand_scan（）函数的最后将会跳至scan_bbt（）函数，这个函数在nand_scan里面有定义：
6. 2415 if (!this->scan_bbt)
7. 2416 this->scan_bbt = nand_default_bbt;
8. nand_default_bbt（）位于Nand_bbt.c文件中。
9. 1047 /**
10. * nand_default_bbt - [NAND Interface] Select a default bad block table for the device
11. * @mtd: MTD device structure
12. *
13. * This selects the default bad block table
14. * support for the device and calls the nand_scan_bbt
15. 　　**/
16. 　　int nand_default_bbt (struct mtd_info *mtd)
17. 　　{
18. 　　 struct nand_chip *this = mtd->priv;
19. 这个函数的作用是建立默认的坏块表。
20. 1059 /* Default for AG-AND. We must use a flash based
21. * bad block table as the devices have factory marked
22. * _good_ blocks. Erasing those blocks leads to loss
23. * of the good / bad information, so we _must_ store
24. * this information in a good / bad table during
25. * startup
26. */
27. if (this->options & NAND_IS_AND) {
28. /* Use the default pattern deors */
29. if (!this->bbt_td) {
30. this->bbt_td = &bbt_main_descr;
31. this->bbt_md = &bbt_mirror_descr;
32. }
33. this->options |= NAND_USE_FLASH_BBT;
34. return nand_scan_bbt (mtd, &agand_flashbased);
35. }
36. 如果Flash的类型是AG-AND（这种Flash类型比较特殊，既不是MLC又不是SLC，因此不去深究了，而且好像瑞萨要把它淘汰掉），需要使用默认的模式描述符，最后再进入nand_scan_bbt（）函数。
37. 1078 /* Is a flash based bad block table requested ? */
38. if (this->options & NAND_USE_FLASH_BBT) {
39. /* Use the default pattern deors */
40. if (!this->bbt_td) {
41. this->bbt_td = &bbt_main_descr;
42. this->bbt_md = &bbt_mirror_descr;
43. }
44. if (!this->badblock_pattern) {
45. this->badblock_pattern = (mtd->oobblock > 512) ?
46. &largepage_flashbased : &smallpage_flashbased;
47. }
48. } else {
49. this->bbt_td = NULL;
50. this->bbt_md = NULL;
51. if (!this->badblock_pattern) {
52. this->badblock_pattern = (mtd->oobblock > 512) ?
53. &largepage_memorybased : &smallpage_memorybased;
54. }
55. }
56. return nand_scan_bbt (mtd, this->badblock_pattern);
57. 如果Flash芯片需要使用坏块表，对于1208芯片来说是使用smallpage_memorybased。
58. 985   static struct nand_bbt_descr smallpage_memorybased = {
59. .options = NAND_BBT_SCAN2NDPAGE,
60. .offs = 5,
61. .len = 1,
62. .pattern = scan_ff_pattern
63. 　　};
64. 暂时没看到如何使用这些赋值，先放着。后面检测坏块时用得着。
65. 1099 return nand_scan_bbt (mtd, this->badblock_pattern);
66. 最后将badblock_pattern作为参数，调用nand_can_bbt函数。
67. 844   /**
68. 　　* nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)
69. * @mtd: MTD device structure
70. * @bd:   deor for the good/bad block search pattern
71. *
72. * The checks, if a bad block table(s) is/are already
73. * available. If not it scans the device for manufacturer
74. * marked good / bad blocks and writes the bad block table(s) to
75. * the selected place.
76. *
77. * The bad block table memory is allocated here. It must be freed
78. * by calling the nand_free_bbt .
79. *
80. 　　*/
81. 　　int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
82. 　　{
83. 检测、寻找、读取甚至建立坏块表。函数检测是否已经存在一张坏块表，否则建立一张。坏块表的内存分配也在这个函数中。
84. 860 struct nand_chip *this = mtd->priv;
85. int len, res = 0;
86. uint8_t *buf;
87. struct nand_bbt_descr *td = this->bbt_td;
88. struct nand_bbt_descr *md = this->bbt_md;
89. len = mtd->size >> (this->bbt_erase_shift + 2);
90. /* Allocate memory (2bit per block) */
91. this->bbt = kmalloc (len, GFP_KERNEL);
92. if (!this->bbt) {
93. printk (KERN_ERR "nand_scan_bbt: Out of memory/n");
94. return -ENOMEM;
95. }
96. /* Clear the memory bad block table */
97. memset (this->bbt, 0x00, len);
98. 一些赋值、变量声明、内存分配，每个block分配2bit的空间。1208有4096个block，应该分配4096*2bit的空间。
99. 877 /* If no primary table decriptor is given, scan the device
100. * to build a memory based bad block table
101. */
102. if (!td) {
103. if ((res = nand_memory_bbt(mtd, bd))) {
104. 　　　　printk (KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT/n");
105. kfree (this->bbt);
106. this->bbt = NULL;
107. }
108. return res;
109. }
110. 如果没有提供ptd，就扫描设备并建立一张。这里调用了nand_memory_bbt（）这个内联函数。
111. 653 /**
112. * nand_memory_bbt - [GENERIC] create a memory based bad block table
113. * @mtd: MTD device structure
114. * @bd:   deor for the good/bad block search pattern
115. *
116. * The creates a memory based bbt by scanning the device
117. * for manufacturer / software marked good / bad blocks
118. 　　*/
119. 　　static inline int nand_memory_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)
120. 　　{
121. struct nand_chip *this = mtd->priv;
122. bd->options &= ~NAND_BBT_SCANEMPTY;
123. return create_bbt (mtd, this->data_buf, bd, -1);
124. 　　}
125. 函数的作用是建立一张基于memory的坏块表。
126. 将操作符的NAND_BBT_SCANEMPTY清除，并继续调用creat_bbt（）函数。
127. 271 /**
128. 　　* create_bbt - [GENERIC] Create a bad block table by scanning the device
129. * @mtd: MTD device structure
130. * @buf: temporary buffer
131. * @bd:   deor for the good/bad block search pattern
132. * @chip: create the table for a specific chip, -1 read all chips.
133. *   Applies only if NAND_BBT_PERCHIP option is set
134. *
135. * Create a bad block table by scanning the device
136. * for the given good/bad block identify pattern
137. */
138. 　　static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd, int chip)
139. 　　{
140. 真正的建立坏块表函数。chip参数是-1表示读取所有的芯片。
141. 284 struct nand_chip *this = mtd->priv;
142. int i, j, numblocks, len, scanlen;
143. int startblock;
144. loff_t from;
145. size_t readlen, ooblen;
146. printk (KERN_INFO "Scanning device for bad blocks/n");
147. 一些变量声明，开机时那句话就是在这儿打印出来的。
148. 292 if (bd->options & NAND_BBT_SCANALLPAGES)
149. len = 1 << (this->bbt_erase_shift - this->page_shift);
150. else {
151. if (bd->options & NAND_BBT_SCAN2NDPAGE)
152. len = 2;
153. else
154. len = 1;
155. }
156. 在前面我们定义了smallpage_memorybased这个结构体，现在里面NAND_BBT_SCANALLPAGES的终于用上了，对于1208芯片来说，len=2。
157. 304 if (!(bd->options & NAND_BBT_SCANEMPTY)) {
158. /* We need only read few bytes from the OOB area */
159. scanlen = ooblen = 0;
160. readlen = bd->len;
161. } else {
162. /* Full page content should be read */
163. scanlen = mtd->oobblock + mtd->oobsize;
164. readlen = len * mtd->oobblock;
165. ooblen = len * mtd->oobsize;
166. }
167. 前面已经将NAND_BBT_SCANEMPTY清除了，这里肯定执行else的内容。需要将一页内容都读取出来。
168. 316 if (chip == -1) {
169. /* Note that numblocks is 2 * (real numblocks) here, see i+=2 below as it
170. * makes shifting and masking less painful */
171. numblocks = mtd->size >> (this->bbt_erase_shift - 1);
172. startblock = 0;
173. from = 0;
174. } else {
175. if (chip >= this->numchips) {
176. printk (KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)/n",
177. chip + 1, this->numchips);
178. return -EINVAL;
179. }
180. numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
181. startblock = chip * numblocks;
182. numblocks += startblock;
183. from = startblock << (this->bbt_erase_shift - 1);
184. }
185. 前面提到chip为-1，实际上我们只有一颗芯片，numblocks这儿是4096*2。
186. 335 for (i = startblock; i < numblocks;) {
187. int ret;
188. if (bd->options & NAND_BBT_SCANEMPTY)
189. if ((ret = nand_read_raw (mtd, buf, from, readlen, ooblen)))
190. return ret;
191. for (j = 0; j < len; j++) {
192. if (!(bd->options & NAND_BBT_SCANEMPTY)) {
193. size_t retlen;
194. /* Read the full oob until read_oob is fixed to
195. * handle single byte reads for 16 bit buswidth */
196. ret = mtd->read_oob(mtd, from + j * mtd->oobblock,
197. mtd->oobsize, &retlen, buf);
198. if (ret)
199. return ret;
200. if (check_short_pattern (buf, bd)) {
201. this->bbt[i >> 3] |= 0x03 << (i & 0x6);
202. printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",
203. i >> 1, (unsigned int) from);
204. break;
205. }
206. } else {
207. if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {
208. this->bbt[i >> 3] |= 0x03 << (i & 0x6);
209. printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",
210. i >> 1, (unsigned int) from);
211. break;
212. }
213. }
214. }
215. i += 2;
216. from += (1 << this->bbt_erase_shift);
217. }
218. return 0;
219. 检测这4096个block，刚开始的nand_read_raw肯定不会执行。len是2，在j循环要循环2次。
220. 每次循环真正要做的事情是下面的内容：
221. ret = mtd->read_oob(mtd, from + j * mtd->oobblock, mtd->oobsize, &retlen, buf);
222. read_oob（）函数在nand_scan（）里被指向nand_read_oob（），这个函数在Nand_base.c文件中，看来得回Nand_base.c看看了。
223. 1397 /**
224. * nand_read_oob - [MTD Interface] NAND read out-of-band
225. * @mtd: MTD device structure
226. * @from: offset to read from
227. * @len: number of bytes to read
228. * @retlen: pointer to variable to store the number of read bytes
229. * @buf: the databuffer to put data
230. *
231. * NAND read out-of-band data from the spare area
232. */
233. static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
234. 　　{
235. 才发现oob全称是out-of-band, from是偏移量，len是读取的长度，retlen是存储指针。
236. 1409 int i, col, page, chipnr;
237. struct nand_chip *this = mtd->priv;
238. int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
239. DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i/n", (unsigned int) from, (int) len);
240. /* Shift to get page */
241. page = (int)(from >> this->page_shift);
242. chipnr = (int)(from >> this->chip_shift);
243. /* Mask to get column */
244. col = from & (mtd->oobsize - 1);
245. /* Initialize return length value */
246. *retlen = 0;
247. 一些初始化，blockcheck对于1208应该是（1<<(0xe-0x9)-1）=31。然后通过偏移量计算出要读取oob区的page，chipnr和col。
248. 1425 /* Do not allow reads past end of device */
249. if ((from + len) > mtd->size) {
250. DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device/n");
251. *retlen = 0;
252. return -EINVAL;
253. }
254. /* Grab the lock and see if the device is available */
255. nand_get_device (this, mtd , FL_READING);
256. /* Select the NAND device */
257. this->select_chip(mtd, chipnr);
258. /* Send the read command */
259. this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);
260. 不允许非法的读取，获取芯片控制权，发送读取OOB命令，这儿会调用具体硬件驱动中相关的Nand控制函数。
261. 1442 /*
262. * Read the data, if we read more than one page
263. * oob data, let the device transfer the data !
264. */
265. i = 0;
266. while (i < len) {
267. int thislen = mtd->oobsize - col;
268. thislen = min_t(int, thislen, len);
269. this->read_buf(mtd, &buf[i], thislen);
270. i += thislen;
271. /* Read more ? */
272. if (i < len) {
273. page++;
274. col = 0;
275. /* Check, if we cross a chip boundary */
276. if (!(page & this->pagemask)) {
277. chipnr++;
278. this->select_chip(mtd, -1);
279. this->select_chip(mtd, chipnr);
280. }
281. /* Apply delay or wait for ready/busy pin
282. * Do this before the AUTOINCR check, so no problems
283. * arise if a chip which does auto increment
284. * is marked as NOAUTOINCR by the board driver.
285. */
286. if (!this->dev_ready)
287. udelay (this->chip_delay);
288. else
289. nand_wait_ready(mtd);
290. /* Check, if the chip supports auto page increment
291. * or if we have hit a block boundary.
292. */
293. if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {
294. /* For subsequent page reads set offset to 0 */
295. this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
296. }
297. }
298. }
299. /* Deselect and wake up anyone waiting on the device */
300. nand_release_device(mtd);
301. /* Return happy */
302. *retlen = len;
303. return 0;
304. 开始读取数据，while循环只要获取到oob区大小的数据即可。注意，read_buf才是最底层的读写Nand的函数，在我们的驱动中根据参数可以实现读取528byte全部内容，或者16byte的oob区。
305. 如果一次没读完，就要继续再读，根据我们实际使用经验好像没出现过这种问题。
306. 最后Return Happy~回到Nand_bbt.c的creat_bbt（）函数，348行，好像都快忘记我们还没出creat_bbt（）函数呢，我再把他贴一遍吧：
307. 346   /* Read the full oob until read_oob is fixed to
308. * handle single byte reads for 16 bit buswidth */
309. ret = mtd->read_oob(mtd, from + j * mtd->oobblock,
310. mtd->oobsize, &retlen, buf);
311. if (ret)
312. return ret;
313. if (check_short_pattern (buf, bd)) {
314. this->bbt[i >> 3] |= 0x03 << (i & 0x6);
315. printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",
316. i >> 1, (unsigned int) from);
317. break;
318. }
319. } else {
320. if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {
321. this->bbt[i >> 3] |= 0x03 << (i & 0x6);
322. printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",
323. i >> 1, (unsigned int) from);
324. break;
325. }
326. }
327. }
328. i += 2;
329. from += (1 << this->bbt_erase_shift);
330. }
331. return 0;
332. 　　}
333. 刚刚如果不是Ruturn Happy，下面的352行就会返回错误了。接着会调用check_short_pattern（）这个函数。
334. 113 /**
335. * check_short_pattern - [GENERIC] check if a pattern is in the buffer
336. * @buf: the buffer to search
337. * @td:   search pattern deor
338. *
339. * Check for a pattern at the given place. Used to search bad block
340. * tables and good / bad block identifiers. Same as check_pattern, but
341. * no optional empty check
342. *
343. 　　*/
344. 　　static int check_short_pattern (uint8_t *buf, struct nand_bbt_descr *td)
345. {
346. int i;
347. uint8_t *p = buf;
348. /* Compare the pattern */
349. for (i = 0; i < td->len; i++) {
350. if (p[td->offs + i] != td->pattern[i])
351. return -1;
352. }
353. return 0;
354. }
355. 检查读到的oob区是不是坏块就靠这个函数了。前面放了好久的struct nand_bbt_descr smallpage_memorybased终于用上了，挨个对比，有一个不一样直接返回-1，坏块就这样产生了。下面会将坏块的位置打印出来，并且将坏块记录在bbt表里面，在nand_scan_bbt（）函数的开始我们就为bbt申请了空间。
356. this->bbt[i >> 3] |= 0x03 << (i & 0x6);
357. 为啥要右移3bit呢？首先i要右移1bit，因为前面乘以了2。由于没个block占用2bit的空间，一个char变量8bit，所以还再要右移2bit吧。
358. 　　下面的check_pattern（）函数调用不到的。
359. 依次检测完所有block，creat_bbt（）函数也顺利返回。
360. 这样nand_memory_bbt（）函数也正确返回。
361. 接着是nand_scan_bbt（）同样顺利结束。
362. 最后nand_default_bbt（）完成。
363. 整个nand_scan（）的工作终于完成咯，好长。

1. bbt坏块管理日月 发表于 - 2010-3-2 9:59:002推荐前面看到在nand_scan（）函数的最后将会跳至scan_bbt（）函数，这个函数在nand_scan里面有定义：2415 if (!this->scan_bbt)2416 this->scan_bbt = nand_default_bbt;nand_default_bbt（）位于Nand_bbt.c文件中。1047 /**    * nand_default_bbt - [NAND Interface] Select a default bad block table for the device    * @mtd: MTD device structure    *    * This selects the default bad block table    * support for the device and calls the nand_scan_bbt　　**/　　int nand_default_bbt (struct mtd_info *mtd)　　{　　 struct nand_chip *this = mtd->priv;这个函数的作用是建立默认的坏块表。1059 /* Default for AG-AND. We must use a flash based   * bad block table as the devices have factory marked   * _good_ blocks. Erasing those blocks leads to loss   * of the good / bad information, so we _must_ store* this information in a good / bad table during* startup   */   if (this->options & NAND_IS_AND) {   /* Use the default pattern deors */   if (!this->bbt_td) {    this->bbt_td = &bbt_main_descr;    this->bbt_md = &bbt_mirror_descr;   }    this->options |= NAND_USE_FLASH_BBT;    return nand_scan_bbt (mtd, &agand_flashbased);   }如果Flash的类型是AG-AND（这种Flash类型比较特殊，既不是MLC又不是SLC，因此不去深究了，而且好像瑞萨要把它淘汰掉），需要使用默认的模式描述符，最后再进入nand_scan_bbt（）函数。1078 /* Is a flash based bad block table requested ? */   if (this->options & NAND_USE_FLASH_BBT) {   /* Use the default pattern deors */   if (!this->bbt_td) {    this->bbt_td = &bbt_main_descr;    this->bbt_md = &bbt_mirror_descr;   }   if (!this->badblock_pattern) {    this->badblock_pattern = (mtd->oobblock > 512) ?     &largepage_flashbased : &smallpage_flashbased;   }   } else {   this->bbt_td = NULL;   this->bbt_md = NULL;   if (!this->badblock_pattern) {    this->badblock_pattern = (mtd->oobblock > 512) ?     &largepage_memorybased : &smallpage_memorybased;   }   }     return nand_scan_bbt (mtd, this->badblock_pattern);如果Flash芯片需要使用坏块表，对于1208芯片来说是使用smallpage_memorybased。985   static struct nand_bbt_descr smallpage_memorybased = {   .options = NAND_BBT_SCAN2NDPAGE,   .offs = 5,   .len = 1,   .pattern = scan_ff_pattern　　};暂时没看到如何使用这些赋值，先放着。后面检测坏块时用得着。1099 return nand_scan_bbt (mtd, this->badblock_pattern);最后将badblock_pattern作为参数，调用nand_can_bbt函数。844   /**　　* nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s)   * @mtd: MTD device structure   * @bd:   deor for the good/bad block search pattern   *   * The checks, if a bad block table(s) is/are already   * available. If not it scans the device for manufacturer   * marked good / bad blocks and writes the bad block table(s) to   * the selected place.   *   * The bad block table memory is allocated here. It must be freed   * by calling the nand_free_bbt .   *　　*/　　int nand_scan_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)　　{检测、寻找、读取甚至建立坏块表。函数检测是否已经存在一张坏块表，否则建立一张。坏块表的内存分配也在这个函数中。860 struct nand_chip *this = mtd->priv;int len, res = 0;uint8_t *buf;struct nand_bbt_descr *td = this->bbt_td;struct nand_bbt_descr *md = this->bbt_md;len = mtd->size >> (this->bbt_erase_shift + 2);/* Allocate memory (2bit per block) */this->bbt = kmalloc (len, GFP_KERNEL);if (!this->bbt) {   printk (KERN_ERR "nand_scan_bbt: Out of memory/n");   return -ENOMEM;}/* Clear the memory bad block table */memset (this->bbt, 0x00, len);一些赋值、变量声明、内存分配，每个block分配2bit的空间。1208有4096个block，应该分配4096*2bit的空间。877 /* If no primary table decriptor is given, scan the device* to build a memory based bad block table*/if (!td) {   if ((res = nand_memory_bbt(mtd, bd))) {　　　　printk (KERN_ERR "nand_bbt: Can't scan flash and build the RAM-based BBT/n");    kfree (this->bbt);    this->bbt = NULL;   }   return res;}如果没有提供ptd，就扫描设备并建立一张。这里调用了nand_memory_bbt（）这个内联函数。653 /**   * nand_memory_bbt - [GENERIC] create a memory based bad block table   * @mtd: MTD device structure   * @bd:   deor for the good/bad block search pattern   *   * The creates a memory based bbt by scanning the device   * for manufacturer / software marked good / bad blocks　　*/　　static inline int nand_memory_bbt (struct mtd_info *mtd, struct nand_bbt_descr *bd)　　{   struct nand_chip *this = mtd->priv;   bd->options &= ~NAND_BBT_SCANEMPTY;   return create_bbt (mtd, this->data_buf, bd, -1);　　}函数的作用是建立一张基于memory的坏块表。将操作符的NAND_BBT_SCANEMPTY清除，并继续调用creat_bbt（）函数。271 /**　　* create_bbt - [GENERIC] Create a bad block table by scanning the device   * @mtd: MTD device structure   * @buf: temporary buffer   * @bd:   deor for the good/bad block search pattern   * @chip: create the table for a specific chip, -1 read all chips.   *   Applies only if NAND_BBT_PERCHIP option is set   *   * Create a bad block table by scanning the device   * for the given good/bad block identify pattern   */　　static int create_bbt (struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd, int chip)　　{真正的建立坏块表函数。chip参数是-1表示读取所有的芯片。284 struct nand_chip *this = mtd->priv;int i, j, numblocks, len, scanlen;int startblock;loff_t from;size_t readlen, ooblen;printk (KERN_INFO "Scanning device for bad blocks/n");一些变量声明，开机时那句话就是在这儿打印出来的。292 if (bd->options & NAND_BBT_SCANALLPAGES)len = 1 << (this->bbt_erase_shift - this->page_shift);else {   if (bd->options & NAND_BBT_SCAN2NDPAGE)    len = 2;   else    len = 1;}在前面我们定义了smallpage_memorybased这个结构体，现在里面NAND_BBT_SCANALLPAGES的终于用上了，对于1208芯片来说，len=2。304 if (!(bd->options & NAND_BBT_SCANEMPTY)) {   /* We need only read few bytes from the OOB area */   scanlen = ooblen = 0;   readlen = bd->len;} else {   /* Full page content should be read */   scanlen = mtd->oobblock + mtd->oobsize;   readlen = len * mtd->oobblock;   ooblen = len * mtd->oobsize;}前面已经将NAND_BBT_SCANEMPTY清除了，这里肯定执行else的内容。需要将一页内容都读取出来。316 if (chip == -1) {   /* Note that numblocks is 2 * (real numblocks) here, see i+=2 below as it   * makes shifting and masking less painful */   numblocks = mtd->size >> (this->bbt_erase_shift - 1);   startblock = 0;   from = 0;} else {   if (chip >= this->numchips) {    printk (KERN_WARNING "create_bbt(): chipnr (%d) > available chips (%d)/n",     chip + 1, this->numchips);    return -EINVAL;   }   numblocks = this->chipsize >> (this->bbt_erase_shift - 1);   startblock = chip * numblocks;   numblocks += startblock;   from = startblock << (this->bbt_erase_shift - 1);}前面提到chip为-1，实际上我们只有一颗芯片，numblocks这儿是4096*2。335 for (i = startblock; i < numblocks;) {   int ret;   if (bd->options & NAND_BBT_SCANEMPTY)    if ((ret = nand_read_raw (mtd, buf, from, readlen, ooblen)))     return ret;   for (j = 0; j < len; j++) {    if (!(bd->options & NAND_BBT_SCANEMPTY)) {     size_t retlen;     /* Read the full oob until read_oob is fixed to     * handle single byte reads for 16 bit buswidth */     ret = mtd->read_oob(mtd, from + j * mtd->oobblock,        mtd->oobsize, &retlen, buf);     if (ret)      return ret;     if (check_short_pattern (buf, bd)) {       this->bbt[i >> 3] |= 0x03 << (i & 0x6);      printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",       i >> 1, (unsigned int) from);        break;     }    } else {     if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {         this->bbt[i >> 3] |= 0x03 << (i & 0x6);      printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",       i >> 1, (unsigned int) from);         break;     }    }   }   i += 2;   from += (1 << this->bbt_erase_shift);}return 0;检测这4096个block，刚开始的nand_read_raw肯定不会执行。len是2，在j循环要循环2次。每次循环真正要做的事情是下面的内容：ret = mtd->read_oob(mtd, from + j * mtd->oobblock, mtd->oobsize, &retlen, buf);read_oob（）函数在nand_scan（）里被指向nand_read_oob（），这个函数在Nand_base.c文件中，看来得回Nand_base.c看看了。1397 /**   * nand_read_oob - [MTD Interface] NAND read out-of-band   * @mtd: MTD device structure   * @from: offset to read from   * @len: number of bytes to read   * @retlen: pointer to variable to store the number of read bytes   * @buf: the databuffer to put data   *   * NAND read out-of-band data from the spare area   */static int nand_read_oob (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)　　{才发现oob全称是out-of-band, from是偏移量，len是读取的长度，retlen是存储指针。1409 int i, col, page, chipnr;struct nand_chip *this = mtd->priv;int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;DEBUG (MTD_DEBUG_LEVEL3, "nand_read_oob: from = 0x%08x, len = %i/n", (unsigned int) from, (int) len);/* Shift to get page */page = (int)(from >> this->page_shift);chipnr = (int)(from >> this->chip_shift);/* Mask to get column */col = from & (mtd->oobsize - 1);/* Initialize return length value */*retlen = 0;一些初始化，blockcheck对于1208应该是（1<<(0xe-0x9)-1）=31。然后通过偏移量计算出要读取oob区的page，chipnr和col。1425 /* Do not allow reads past end of device */if ((from + len) > mtd->size) {   DEBUG (MTD_DEBUG_LEVEL0, "nand_read_oob: Attempt read beyond end of device/n");   *retlen = 0;   return -EINVAL;}/* Grab the lock and see if the device is available */nand_get_device (this, mtd , FL_READING);/* Select the NAND device */this->select_chip(mtd, chipnr);/* Send the read command */this->cmdfunc (mtd, NAND_CMD_READOOB, col, page & this->pagemask);不允许非法的读取，获取芯片控制权，发送读取OOB命令，这儿会调用具体硬件驱动中相关的Nand控制函数。1442 /** Read the data, if we read more than one page* oob data, let the device transfer the data !*/i = 0;while (i < len) {   int thislen = mtd->oobsize - col;   thislen = min_t(int, thislen, len);   this->read_buf(mtd, &buf[i], thislen);   i += thislen;   /* Read more ? */   if (i < len) {    page++;    col = 0;    /* Check, if we cross a chip boundary */    if (!(page & this->pagemask)) {     chipnr++;     this->select_chip(mtd, -1);     this->select_chip(mtd, chipnr);    }    /* Apply delay or wait for ready/busy pin    * Do this before the AUTOINCR check, so no problems    * arise if a chip which does auto increment    * is marked as NOAUTOINCR by the board driver.    */    if (!this->dev_ready)     udelay (this->chip_delay);    else     nand_wait_ready(mtd);    /* Check, if the chip supports auto page increment    * or if we have hit a block boundary.    */    if (!NAND_CANAUTOINCR(this) || !(page & blockcheck)) {     /* For subsequent page reads set offset to 0 */           this->cmdfunc (mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);    }   }}/* Deselect and wake up anyone waiting on the device */nand_release_device(mtd);/* Return happy */*retlen = len;return 0;开始读取数据，while循环只要获取到oob区大小的数据即可。注意，read_buf才是最底层的读写Nand的函数，在我们的驱动中根据参数可以实现读取528byte全部内容，或者16byte的oob区。如果一次没读完，就要继续再读，根据我们实际使用经验好像没出现过这种问题。最后Return Happy~回到Nand_bbt.c的creat_bbt（）函数，348行，好像都快忘记我们还没出creat_bbt（）函数呢，我再把他贴一遍吧：346   /* Read the full oob until read_oob is fixed to   * handle single byte reads for 16 bit buswidth */   ret = mtd->read_oob(mtd, from + j * mtd->oobblock,        mtd->oobsize, &retlen, buf);     if (ret)      return ret;     if (check_short_pattern (buf, bd)) {       this->bbt[i >> 3] |= 0x03 << (i & 0x6);      printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",       i >> 1, (unsigned int) from);        break;     }    } else {     if (check_pattern (&buf[j * scanlen], scanlen, mtd->oobblock, bd)) {         this->bbt[i >> 3] |= 0x03 << (i & 0x6);      printk (KERN_WARNING "Bad eraseblock %d at 0x%08x/n",       i >> 1, (unsigned int) from);         break;     }    }   }   i += 2;   from += (1 << this->bbt_erase_shift);}return 0;　　}刚刚如果不是Ruturn Happy，下面的352行就会返回错误了。接着会调用check_short_pattern（）这个函数。113 /**   * check_short_pattern - [GENERIC] check if a pattern is in the buffer   * @buf: the buffer to search   * @td:   search pattern deor   *   * Check for a pattern at the given place. Used to search bad block   * tables and good / bad block identifiers. Same as check_pattern, but   * no optional empty check   *　　*/　　static int check_short_pattern (uint8_t *buf, struct nand_bbt_descr *td){int i;uint8_t *p = buf;/* Compare the pattern */for (i = 0; i < td->len; i++) {   if (p[td->offs + i] != td->pattern[i])    return -1;}return 0;}检查读到的oob区是不是坏块就靠这个函数了。前面放了好久的struct nand_bbt_descr smallpage_memorybased终于用上了，挨个对比，有一个不一样直接返回-1，坏块就这样产生了。下面会将坏块的位置打印出来，并且将坏块记录在bbt表里面，在nand_scan_bbt（）函数的开始我们就为bbt申请了空间。this->bbt[i >> 3] |= 0x03 << (i & 0x6);为啥要右移3bit呢？首先i要右移1bit，因为前面乘以了2。由于没个block占用2bit的空间，一个char变量8bit，所以还再要右移2bit吧。　　下面的check_pattern（）函数调用不到的。依次检测完所有block，creat_bbt（）函数也顺利返回。这样nand_memory_bbt（）函数也正确返回。接着是nand_scan_bbt（）同样顺利结束。最后nand_default_bbt（）完成。整个nand_scan（）的工作终于完成咯，好长。

MTD的坏块管理(一)-快速了解MTD的坏块管理

MTD坏块管理(二)-内核获取Nandflash的参数过程