uboot之nand flash相关(3)

然后我们分析一下nand flash的读写等函数。

既然是命令那自然要看到U_BOOT_CMD宏，这个宏分析的很多就不分析了。在cmd_nand.c文件中。nand的命令执行函数是do_nand。当然我们没有定义CFG_NAND_LEGACY,要看这个分支。do_nand函数也没有什么好分析的，摘取几个命令的处理分析下。

1。nand bad命令

列出函数调用次序先，

do_nand

nand_block_isbad//include/nand.h

nand_block_isbad//在Nand_base.c中， info->block_isbad函数指针指向

nand_block_checkbad//在Nand_base.c

nand_block_bad() //在Nand_base.c中，nand_chip,this->block_bad函数指针指向,

nand_isbad_bbt //在Nand_bbt.c中

如下。

点击(此处)折叠或打开

1. nand = &nand_info[nand_curr_device];
   
2. if (strcmp(cmd, "bad") == 0) {
   
3. printf("\nDevice %d bad blocks:\n", nand_curr_device);
   
4. for (off = 0; off < nand->size; off += nand->erasesize) //按块循环
   
5. if (nand_block_isbad(nand, off)) //(1)
   
6. printf(" %08x\n", off);
   
7. return 0;
   
8. }

这个函数的定义在include/nand.h中，它调用nand_info[]变量中的block_isbad函数指针指向的函数;这个指针在初始化时已经被分配，这里是Nand_base.c文件中的nand_block_isbad函数。这里有个小问题，那有两个都被编译的nand_block_isbad函数的定义，那到底调用的是哪个呢。答案是nand.h中的，因为Nand_base.c中的是被定义成static的函数，只能在本文件中使用。

点击(此处)折叠或打开

1. static int nand_block_isbad (struct mtd_info *mtd, loff_t ofs)
   
2. {
   
3. /* Check for invalid offset */
   
4. if (ofs > mtd->size)
   
5. return -EINVAL;
   
6. 
   
7. return nand_block_checkbad (mtd, ofs, 1, 0);
   
8. }

这个函数又会调用nand_block_checkbad 函数

点击(此处)折叠或打开

1. static int nand_block_checkbad (struct mtd_info *mtd, loff_t ofs, int getchip, int allowbbt)
   
2. {
   
3. struct nand_chip *this = mtd->priv;
   
4. 
   
5. if (!this->bbt) //如果nand_chip结构体变量中的bbt（坏块标记表）表指针是空的
   
6. return this->block_bad(mtd, ofs, getchip);
   
7. 
   
8. /* Return info from the table */
   
9. return nand_isbad_bbt (mtd, ofs, allowbbt);
   
10. }

block_bad函数指针被指向nand_block_bad，分析它，

此函数将从芯片读取坏块标记

点击(此处)折叠或打开

1. static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
   
2. {
   
3. int page, chipnr, res = 0;
   
4. struct nand_chip *this = mtd->priv;
   
5. u16 bad;
   
6. 
   
7. page = (int)(ofs >> this->page_shift) & this->pagemask; //(1)
   
8. 
   
9. if (getchip) { //选中芯片
   
10. chipnr = (int)(ofs >> this->chip_shift);
    
11. 
    
12. /* Grab the lock and see if the device is available */
    
13. nand_get_device (this, mtd, FL_READING);
    
14. 
    
15. /* Select the NAND device */
    
16. this->select_chip(mtd, chipnr);
    
17. }
    
18. 
    
19. if (this->options & NAND_BUSWIDTH_16) {
    
20. this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos & 0xFE, page);
    
21. bad = cpu_to_le16(this->read_word(mtd));
    
22. if (this->badblockpos & 0x1)
    
23. bad >>= 1;
    
24. if ((bad & 0xFF) != 0xff)
    
25. res = 1;
    
26. } else {
    
27. this->cmdfunc (mtd, NAND_CMD_READOOB, this->badblockpos, page); //(2)
    
28. if (this->read_byte(mtd) != 0xff) //(3)
    
29. res = 1;
    
30. }
    
31. 
    
32. if (getchip) {
    
33. /* Deselect and wake up anyone waiting on the device */
    
34. nand_release_device(mtd);
    
35. }
    
36. 
    
37. return res;
    
38. }

(1)从偏移地址获取页号。page_shift是page页位数（就是一页的大小的数值用二进制表示最高位的序号）。将偏移地址右移页位数，则低位就是页的号码，有相当于除页大小。然后在与上pagemask，就是页大小（主要是将高位置0，其实这里与不与感觉都无所谓，高位本来就是0）

(2)主要就是这一句，cmdfunc()函数，发送读取oob区命令。this->badblockpos在nand_scan函数中设置了大页0，小页5。

(3)读出的位是否是0xff，如果不是就是坏块。

...................................

再看下如果有bbt表，nand_block_checkbad函数将调用nand_isbad_bbt。bbt表在初始化时scan_bbt函数已经建立。所以nand bad命令在这个uboot中都是通过查bbt表完成的。

点击(此处)折叠或打开

1. int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt)
   
2. {
   
3. struct nand_chip *this = mtd->priv;
   
4. int block;
   
5. uint8_t res;
   
6. 
   
7. /* Get block number * 2 */
   
8. block = (int) (offs >> (this->bbt_erase_shift - 1)); //(1)
   
9. res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03; //(2)
   
10. 
    
11. DEBUG (MTD_DEBUG_LEVEL2, "nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n",
    
12. (unsigned int)offs, res, block >> 1);
    
13. 
    
14. switch ((int)res) {
    
15. case 0x00: return 0;
    
16. case 0x01: return 1;
    
17. case 0x02: return allowbbt ? 0 : 1;
    
18. }
    
19. return 1;
    
20. }

nand bad命令处理暂时分析到这里

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

分析nand read 命令：

nand read命令的调用顺序为：

do_nand //cmd_nand.c

nand_read_opts ///driver/mtd/nand/nand_util.c

nand_read //nand_base.c ,meminfo->read指针指向

nand_read_ecc //nand_base.c

sep4020_nand_read_buf//cpu/sep4020/nand_flash.c

这里的代码大多照搬了内核的mtd层代码，而仅仅对于uboot不需要这么复杂，一些操作觉得不合理，有很多无用又费周折的操作。

do_nand函数中read相关部分：

点击(此处)折叠或打开

1. if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
   
2. int read;
   
3. 
   
4. if (argc < 4)
   
5. goto usage;
   
6. 
   
7. addr = (ulong)simple_strtoul(argv[2], NULL, 16);
   
8. 
   
9. read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
   
10. printf("\nNAND %s: ", read ? "read" : "write");
    
11. if (arg_off_size(argc - 3, argv + 3, nand, &off, &size) != 0)
    
12. return 1;
    
13. 
    
14. s = strchr(cmd, '.');
    
15. if (s != NULL &&
    
16. (!strcmp(s, ".jffs2") || !strcmp(s, ".e") || !strcmp(s, ".i"))) {
    
17. if (read) {
    
18. /* read */
    
19. nand_read_options_t opts;
    
20. memset(&opts, 0, sizeof(opts));
    
21. opts.buffer = (u_char*) addr; //addr是内存地址，nand读出来的数据最终将存入这里
    
22. opts.length = size; //读取的大小
    
23. opts.offset = off; //flash地址
    
24. opts.quiet = quiet;
    
25. ret = nand_read_opts(nand, &opts); //读数据操作，opts将保存必要的信息。
    
26. } else {
    
27. /* write */
    
28. nand_write_options_t opts;
    
29. memset(&opts, 0, sizeof(opts));
    
30. opts.buffer = (u_char*) addr;
    
31. opts.length = size;
    
32. opts.offset = off;
    
33. /* opts.forcejffs2 = 1; */
    
34. opts.pad = 1;
    
35. opts.blockalign = 1;
    
36. opts.quiet = quiet;
    
37. ret = nand_write_opts(nand, &opts);
    
38. }
    
39. } else if (s != NULL && !strcmp(s, ".yaffs")) {
    
40. if (read) {
    
41. /* read */
    
42. nand_read_options_t opts;
    
43. memset(&opts, 0, sizeof(opts));
    
44. opts.buffer = (u_char*) addr;
    
45. opts.length = size;
    
46. opts.offset = off;
    
47. opts.quiet = quiet;
    
48. ret = nand_read_opts(nand, &opts);
    
49. } else {
    
50. /* write */
    
51. nand_write_options_t opts;
    
52. memset(&opts, 0, sizeof(opts));
    
53. opts.buffer = (u_char*) addr;
    
54. opts.length = size;
    
55. opts.offset = off;
    
56. /* opts.forceyaffs = 1; */
    
57. opts.noecc = 1;
    
58. opts.writeoob = 1;
    
59. opts.blockalign = 1;
    
60. opts.quiet = quiet;
    
61. opts.skipfirstblk = 1;
    
62. ret = nand_write_opts(nand, &opts);
    
63. }
    
64. 
    
65. 
    
66. } else if (s != NULL && !strcmp(s, ".oob")) {
    
67. /* read out-of-band data */
    
68. if (read)
    
69. ret = nand->read_oob(nand, off, size, &size,
    
70. (u_char *) addr);
    
71. else
    
72. ret = nand->write_oob(nand, off, size, &size,
    
73. (u_char *) addr);
    
74. } else {
    
75. if (read)
    
76. ret = nand_read(nand, off, &size, (u_char *)addr);
    
77. else
    
78. ret = nand_write(nand, off, &size, (u_char *)addr);
    
79. }
    
80. 
    
81. printf(" %d bytes %s: %s\n", size,
    
82. read ? "read" : "written", ret ? "ERROR" : "OK");
    
83. 
    
84. return ret == 0 ? 0 : 1;
    
85. }

nand_read_opts在/driver/mtd/nand/nand_util.c，参照代码中原本的英文注释，代码量大也就不做详细分析了

点击(此处)折叠或打开

1. /**
   
2. * nand_read_opts: - read image from NAND flash with support for various options
   
3. *
   
4. * @param meminfo NAND device to erase
   
5. * @param opts read options (@see struct nand_read_options)
   
6. * @return 0 in case of success
   
7. *
   
8. */
   
9. int nand_read_opts(nand_info_t *meminfo, const nand_read_options_t *opts)
   
10. {
    
11. int imglen = opts->length;
    
12. int pagelen;
    
13. int baderaseblock;
    
14. int blockstart = -1;
    
15. int percent_complete = -1;
    
16. loff_t offs;
    
17. size_t readlen;
    
18. ulong mtdoffset = opts->offset;
    
19. u_char *buffer = opts->buffer;
    
20. int result;
    
21. 
    
22. /* make sure device page sizes are valid */
    
23. if (!(meminfo->oobsize == 16 && meminfo->oobblock == 512)
    
24. && !(meminfo->oobsize == 8 && meminfo->oobblock == 256)
    
25. && !(meminfo->oobsize == 64 && meminfo->oobblock == 2048)) {
    
26. printf("Unknown flash (not normal NAND)\n");
    
27. return -1;
    
28. }
    
29. 
    
30. pagelen = meminfo->oobblock
    
31. + ((opts->readoob != 0) ? meminfo->oobsize : 0);
    
32. 
    
33. /* check, if length is not larger than device */
    
34. if (((imglen / pagelen) * meminfo->oobblock)
    
35. > (meminfo->size - opts->offset)) {
    
36. printf("Image %d bytes, NAND page %d bytes, "
    
37. "OOB area %u bytes, device size %u bytes\n",
    
38. imglen, pagelen, meminfo->oobblock, meminfo->size);
    
39. printf("Input block is larger than device\n");
    
40. return -1;
    
41. }
    
42. 
    
43. if (!opts->quiet)
    
44. printf("\n");
    
45. 
    
46. /* get data from input and write to the device */
    
47. while (imglen && (mtdoffset < meminfo->size)) {
    
48. 
    
49. WATCHDOG_RESET ();
    
50. 
    
51. /*
    
52. * new eraseblock, check for bad block(s). Stay in the
    
53. * loop to be sure if the offset changes because of
    
54. * a bad block, that the next block that will be
    
55. * written to is also checked. Thus avoiding errors if
    
56. * the block(s) after the skipped block(s) is also bad
    
57. * (number of blocks depending on the blockalign
    
58. */
    
59. while (blockstart != (mtdoffset & (~meminfo->erasesize+1))) {
    
60. blockstart = mtdoffset & (~meminfo->erasesize+1);
    
61. offs = blockstart;
    
62. baderaseblock = 0;
    
63. 
    
64. /* check all the blocks in an erase block for
    
65. * bad blocks */
    
66. do {
    
67. int ret = meminfo->block_isbad(meminfo, offs);
    
68. 
    
69. if (ret < 0) {
    
70. printf("Bad block check failed\n");
    
71. return -1;
    
72. }
    
73. if (ret == 1) {
    
74. baderaseblock = 1;
    
75. if (!opts->quiet)
    
76. printf("\rBad block at 0x%lx "
    
77. "in erase block from "
    
78. "0x%x will be skipped\n",
    
79. (long) offs,
    
80. blockstart);
    
81. }
    
82. 
    
83. if (baderaseblock) {
    
84. mtdoffset = blockstart
    
85. + meminfo->erasesize;
    
86. }
    
87. offs += meminfo->erasesize;
    
88. 
    
89. } while (offs < blockstart + meminfo->erasesize);
    
90. }
    
91. 
    
92. 
    
93. /* read page data to memory buffer */
    
94. result = meminfo->read(meminfo, //读2048字节(不包含oob的一页)，
    
95. mtdoffset, //nand flash地址
    
96. meminfo->oobblock, //页大小（2048）,即需要读取的字节数
    
97. &readlen,
    
98. (unsigned char *) &data_buf);
    
99. 
    
100. if (result != 0) {
     
101. printf("reading NAND page at offset 0x%lx failed\n",
     
102. mtdoffset);
     
103. return -1;
     
104. }
     
105. 
     
106. if (imglen < readlen) {
     
107. readlen = imglen;
     
108. }
     
109. 
     
110. memcpy(buffer, data_buf, readlen);
     
111. buffer += readlen;
     
112. imglen -= readlen;
     
113. 
     
114. //上面是读页有效数据（2048），这里读oob数据。
     
115. if (opts->readoob) {
     
116. result = meminfo->read_oob(meminfo,
     
117. mtdoffset,
     
118. meminfo->oobsize,
     
119. &readlen,
     
120. (unsigned char *)
     
121. &oob_buf);
     
122. 
     
123. if (result != 0) {
     
124. printf("\nMTD readoob failure: %d\n",
     
125. result);
     
126. return -1;
     
127. }
     
128. 
     
129. 
     
130. if (imglen < readlen) {
     
131. readlen = imglen;
     
132. }
     
133. 
     
134. memcpy(buffer, oob_buf, readlen);
     
135. 
     
136. buffer += readlen;
     
137. imglen -= readlen;
     
138. }
     
139. 
     
140. if (!opts->quiet) {
     
141. unsigned long long n = (unsigned long long)
     
142. (opts->length-imglen) * 100;
     
143. int percent;
     
144. 
     
145. do_div(n, opts->length);
     
146. percent = (int)n;
     
147. 
     
148. /* output progress message only at whole percent
     
149. * steps to reduce the number of messages printed
     
150. * on (slow) serial consoles
     
151. */
     
152. if (percent != percent_complete) {
     
153. if (!opts->quiet)
     
154. printf("\rReading data from 0x%x "
     
155. "-- %3d%% complete.",
     
156. mtdoffset, percent);
     
157. percent_complete = percent;
     
158. }
     
159. }
     
160. 
     
161. mtdoffset += meminfo->oobblock;
     
162. }
     
163. 
     
164. if (!opts->quiet)
     
165. printf("\n");
     
166. 
     
167. if (imglen > 0) {
     
168. printf("Could not read entire image due to bad blocks\n");
     
169. return -1;
     
170. }
     
171. 
     
172. /* return happy */
     
173. return 0;
     
174. }

上面meminfo->read指向的函数是，nand_read在nand_base.c文件中。

点击(此处)折叠或打开

1. static int nand_read (struct mtd_info *mtd, loff_t from, size_t len, size_t * retlen, u_char * buf)
   
2. {
   
3. return nand_read_ecc (mtd, from, len, retlen, buf, NULL, NULL);
   
4. }

nand_read_ecc函数在nand_base.c中，函数如下

点击(此处)折叠或打开

1. /**
   
2. * nand_read_ecc - [MTD Interface] Read data with ECC
   
3. * @mtd: MTD device structure
   
4. * @from: offset to read from
   
5. * @len: number of bytes to read
   
6. * @retlen: pointer to variable to store the number of read bytes
   
7. * @buf: the databuffer to put data
   
8. * @oob_buf: filesystem supplied oob data buffer
   
9. * @oobsel: oob selection structure
   
10. *
    
11. * NAND read with ECC
    
12. */
    
13. static int nand_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
    
14. size_t * retlen, u_char * buf, u_char * oob_buf, struct nand_oobinfo *oobsel)
    
15. {
    
16. int i, j, col, realpage, page, end, ecc, chipnr, sndcmd = 1;
    
17. int read = 0, oob = 0, ecc_status = 0, ecc_failed = 0;
    
18. struct nand_chip *this = mtd->priv;
    
19. u_char *data_poi, *oob_data = oob_buf;
    
20. u_char ecc_calc[32];
    
21. u_char ecc_code[32];
    
22. int eccmode, eccsteps;
    
23. unsigned *oob_config;
    
24. int datidx;
    
25. int blockcheck = (1 << (this->phys_erase_shift - this->page_shift)) - 1;
    
26. int eccbytes;
    
27. int compareecc = 1;
    
28. int oobreadlen;
    
29. 
    
30. 
    
31. DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);
    
32. 
    
33. /* Do not allow reads past end of device */
    
34. if ((from + len) > mtd->size) {
    
35. DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: Attempt read beyond end of device\n");
    
36. *retlen = 0;
    
37. return -EINVAL;
    
38. }
    
39. 
    
40. /* Grab the lock and see if the device is available */
    
41. nand_get_device (this, mtd ,FL_READING);
    
42. 
    
43. /* use userspace supplied oobinfo, if zero */
    
44. if (oobsel == NULL)
    
45. oobsel = &mtd->oobinfo;
    
46. 
    
47. /* Autoplace of oob data ? Use the default placement scheme */
    
48. if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
    
49. oobsel = this->autooob;
    
50. 
    
51. eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
    
52. oob_config = oobsel->eccpos;
    
53. 
    
54. /* Select the NAND device */
    
55. chipnr = (int)(from >> this->chip_shift);
    
56. this->select_chip(mtd, chipnr);
    
57. 
    
58. /* First we calculate the starting page */
    
59. realpage = (int) (from >> this->page_shift);
    
60. page = realpage & this->pagemask;
    
61. 
    
62. /* Get raw starting column */
    
63. col = from & (mtd->oobblock - 1);
    
64. 
    
65. end = mtd->oobblock;
    
66. ecc = this->eccsize;
    
67. eccbytes = this->eccbytes;
    
68. 
    
69. if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
    
70. compareecc = 0;
    
71. 
    
72. oobreadlen = mtd->oobsize;
    
73. if (this->options & NAND_HWECC_SYNDROME)
    
74. oobreadlen -= oobsel->eccbytes;
    
75. 
    
76. /* Loop until all data read */
    
77. while (read < len) {
    
78. 
    
79. int aligned = (!col && (len - read) >= end);
    
80. /*
    
81. * If the read is not page aligned, we have to read into data buffer
    
82. * due to ecc, else we read into return buffer direct
    
83. */
    
84. if (aligned)
    
85. data_poi = &buf[read];
    
86. else
    
87. data_poi = this->data_buf;
    
88. 
    
89. /* Check, if we have this page in the buffer
    
90. *
    
91. * FIXME: Make it work when we must provide oob data too,
    
92. * check the usage of data_buf oob field
    
93. */
    
94. if (realpage == this->pagebuf && !oob_buf) {
    
95. /* aligned read ? */
    
96. if (aligned)
    
97. memcpy (data_poi, this->data_buf, end);
    
98. goto readdata;
    
99. }
    
100. 
     
101. /* Check, if we must send the read command */
     
102. if (sndcmd) { //板级读命令发送，其实这里主要设置了nandflash的地址。
     
103. this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page);
     
104. sndcmd = 0;
     
105. }
     
106. 
     
107. /* get oob area, if we have no oob buffer from fs-driver */
     
108. if (!oob_buf || oobsel->useecc == MTD_NANDECC_AUTOPLACE ||
     
109. oobsel->useecc == MTD_NANDECC_AUTOPL_USR)
     
110. oob_data = &this->data_buf[end];
     
111. 
     
112. eccsteps = this->eccsteps;
     
113. 
     
114. switch (eccmode) {
     
115. case NAND_ECC_NONE: { /* No ECC, Read in a page */
     
116. /* XXX U-BOOT XXX */
     
117. #if 0
     
118. static unsigned long lastwhinge = 0;
     
119. if ((lastwhinge / HZ) != (jiffies / HZ)) {
     
120. printk (KERN_WARNING "Reading data from NAND FLASH without ECC is not recommended\n");
     
121. lastwhinge = jiffies;
     
122. }
     
123. #else
     
124. puts("Reading data from NAND FLASH without ECC is not recommended\n");
     
125. #endif
     
126. this->read_buf(mtd, data_poi, end);
     
127. break;
     
128. }
     
129. 
     
130. case NAND_ECC_SOFT: /* Software ECC 3/256: Read in a page + oob data */
     
131. this->read_buf(mtd, data_poi, end); //读取数据
     
132. for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=3, datidx += ecc)
     
133. this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
     
134. break;
     
135. 
     
136. default:
     
137. for (i = 0, datidx = 0; eccsteps; eccsteps--, i+=eccbytes, datidx += ecc) {
     
138. this->enable_hwecc(mtd, NAND_ECC_READ);
     
139. this->read_buf(mtd, &data_poi[datidx], ecc);
     
140. 
     
141. /* HW ecc with syndrome calculation must read the
     
142. * syndrome from flash immidiately after the data */
     
143. if (!compareecc) {
     
144. /* Some hw ecc generators need to know when the
     
145. * syndrome is read from flash */
     
146. this->enable_hwecc(mtd, NAND_ECC_READSYN);
     
147. this->read_buf(mtd, &oob_data[i], eccbytes);
     
148. /* We calc error correction directly, it checks the hw
     
149. * generator for an error, reads back the syndrome and
     
150. * does the error correction on the fly */
     
151. if (this->correct_data(mtd, &data_poi[datidx], &oob_data[i], &ecc_code[i]) == -1) {
     
152. DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: "
     
153. "Failed ECC read, page 0x%08x on chip %d\n", page, chipnr);
     
154. ecc_failed++;
     
155. }
     
156. } else {
     
157. this->calculate_ecc(mtd, &data_poi[datidx], &ecc_calc[i]);
     
158. }
     
159. }
     
160. break;
     
161. }
     
162. 
     
163. /* read oobdata */
     
164. this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);
     
165. 
     
166. /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
     
167. if (!compareecc)
     
168. goto readoob;
     
169. 
     
170. /* Pick the ECC bytes out of the oob data */
     
171. for (j = 0; j < oobsel->eccbytes; j++)
     
172. ecc_code[j] = oob_data[oob_config[j]];
     
173. 
     
174. /* correct data, if neccecary */
     
175. for (i = 0, j = 0, datidx = 0; i < this->eccsteps; i++, datidx += ecc) {
     
176. ecc_status = this->correct_data(mtd, &data_poi[datidx], &ecc_code[j], &ecc_calc[j]);
     
177. 
     
178. /* Get next chunk of ecc bytes */
     
179. j += eccbytes;
     
180. 
     
181. /* Check, if we have a fs supplied oob-buffer,
     
182. * This is the legacy mode. Used by YAFFS1
     
183. * Should go away some day
     
184. */
     
185. if (oob_buf && oobsel->useecc == MTD_NANDECC_PLACE) {
     
186. int *p = (int *)(&oob_data[mtd->oobsize]);
     
187. p[i] = ecc_status;
     
188. }
     
189. 
     
190. if (ecc_status == -1) {
     
191. DEBUG (MTD_DEBUG_LEVEL0, "nand_read_ecc: " "Failed ECC read, page 0x%08x\n", page);
     
192. ecc_failed++;
     
193. }
     
194. }
     
195. 
     
196. readoob:
     
197. /* check, if we have a fs supplied oob-buffer */
     
198. if (oob_buf) {
     
199. /* without autoplace. Legacy mode used by YAFFS1 */
     
200. switch(oobsel->useecc) {
     
201. case MTD_NANDECC_AUTOPLACE:
     
202. case MTD_NANDECC_AUTOPL_USR:
     
203. /* Walk through the autoplace chunks */
     
204. for (i = 0, j = 0; j < mtd->oobavail; i++) {
     
205. int from = oobsel->oobfree[i][0];
     
206. int num = oobsel->oobfree[i][1];
     
207. memcpy(&oob_buf[oob+j], &oob_data[from], num);
     
208. j+= num;
     
209. }
     
210. oob += mtd->oobavail;
     
211. break;
     
212. case MTD_NANDECC_PLACE:
     
213. /* YAFFS1 legacy mode */
     
214. oob_data += this->eccsteps * sizeof (int);
     
215. default:
     
216. oob_data += mtd->oobsize;
     
217. }
     
218. }
     
219. readdata:
     
220. /* Partial page read, transfer data into fs buffer */
     
221. if (!aligned) {
     
222. for (j = col; j < end && read < len; j++)
     
223. buf[read++] = data_poi[j];
     
224. this->pagebuf = realpage;
     
225. } else
     
226. read += mtd->oobblock;
     
227. 
     
228. /* Apply delay or wait for ready/busy pin
     
229. * Do this before the AUTOINCR check, so no problems
     
230. * arise if a chip which does auto increment
     
231. * is marked as NOAUTOINCR by the board driver.
     
232. */
     
233. if (!this->dev_ready)
     
234. udelay (this->chip_delay);
     
235. else
     
236. while (!this->dev_ready(mtd));
     
237. 
     
238. if (read == len)
     
239. break;
     
240. 
     
241. /* For subsequent reads align to page boundary. */
     
242. col = 0;
     
243. /* Increment page address */
     
244. realpage++;
     
245. 
     
246. page = realpage & this->pagemask;
     
247. /* Check, if we cross a chip boundary */
     
248. if (!page) {
     
249. chipnr++;
     
250. this->select_chip(mtd, -1);
     
251. this->select_chip(mtd, chipnr);
     
252. }
     
253. /* Check, if the chip supports auto page increment
     
254. * or if we have hit a block boundary.
     
255. */
     
256. if (!NAND_CANAUTOINCR(this) || !(page & blockcheck))
     
257. sndcmd = 1;
     
258. }
     
259. 
     
260. /* Deselect and wake up anyone waiting on the device */
     
261. nand_release_device(mtd);
     
262. 
     
263. /*
     
264. * Return success, if no ECC failures, else -EBADMSG
     
265. * fs driver will take care of that, because
     
266. * retlen == desired len and result == -EBADMSG
     
267. */
     
268. *retlen = read;
     
269. return ecc_failed ? -EBADMSG : 0;
     
270. }

this->cmdfunc (mtd, NAND_CMD_READ0, 0x00, page)函数指针指向的函数为sep4020_nand_command函数

点击(此处)折叠或打开

1. static void sep4020_nand_command (struct mtd_info *mtd, unsigned command, int column, int page_addr)
   
2. {
   
3. register struct nand_chip *this = mtd->priv;
   
4. 
   
5. if(command == NAND_CMD_READOOB) //(1)
   
6. {
   
7. column += mtd->oobblock;
   
8. command = NAND_CMD_READ0;
   
9. }
   
10. //column是坏块在oob中的位置，加上oobblock（就是页大小pagesiz，不知道为什么起这个名字oobblock）,这样就是
    
11. //地址中的列地址。command命令赋值NAND_CMD_READ0（0）,读命令。
    
12. 
    
13. this->hwcontrol(mtd, NAND_CTL_SETCLE);
    
14. //命令引脚使能
    
15. 
    
16. switch(command)
    
17. {
    
18. case NAND_CMD_READ0:
    
19. *(volatile unsigned long*)EMI_NAND_COM_RAW = 0x40003000;
    
20. //这个寄存器[7:0]命令的第一个字节00 [15:8]是命令的第二个字节30 .
    
21. //最高位是使能位（暂不开启），30位是字节表示1字节还是2字节命令。4=0100
    
22. break;
    
23. case NAND_CMD_SEQIN:
    
24. *(volatile unsigned long*)EMI_NAND_COM_RAW = 0x40001080;
    
25. // 80,10 写flash
    
26. break;
    
27. default:
    
28. this->write_byte(mtd,command);
    
29. break;
    
30. }
    
31. this->hwcontrol(mtd,NAND_CTL_CLRCLE);
    
32. //命令引脚无效
    
33. if (command == NAND_CMD_READID)
    
34. {
    
35. EMI_NAND_COM |= 0x80000000; //使能EMI_NAND_COM
    
36. this->hwcontrol(mtd, NAND_READ_ID);
    
37. return;
    
38. }
    
39. 
    
40. if (command == NAND_CMD_STATUS)
    
41. {
    
42. EMI_NAND_COM |= 0x80000000; //使能EMI_NAND_COM
    
43. this->hwcontrol(mtd, NAND_READ_STATUS);
    
44. }
    
45. 
    
46. if (command == NAND_CMD_RESET)
    
47. {
    
48. EMI_NAND_COM |= 0x80000000;
    
49. this->hwcontrol(mtd, NAND_CTL_CLRALE);
    
50. }
    
51. /* Set ALE and clear CLE to start address cycle */
    
52. 
    
53. if (column != -1 || page_addr != -1) {
    
54. this->hwcontrol(mtd, NAND_CTL_SETALE); //这里这个函数其实没什么用。
    
55. EMI_NAND_ADDR1 = page_addr<<16; //page_addr是页号。128M，2Kflash一共就64K页
    
56. EMI_NAND_ADDR2 = page_addr>>16; //对于一共总数64K的页，这个值等于0
    
57. this->hwcontrol(mtd, NAND_CTL_CLRALE);
    
58. }
    
59. //
    
60. 
    
61. }

分析sep4020_hwcontrol函数。此函数之所以存在，应该是为了和MCU通过引脚直接控制或其他MCU的nand flash的代码结构保持兼容，此处此函数的主要作用是将IO_ADDR_W替换成对应的寄存器地址

点击(此处)折叠或打开

1. static void sep4020_hwcontrol(struct mtd_info *mtd, int cmd)
   
2. {
   
3. struct nand_chip *this = mtd->priv;
   
4. 
   
5. switch (cmd) {
   
6. case NAND_CTL_SETNCE:
   
7. case NAND_CTL_CLRNCE:
   
8. break;
   
9. //对于nCE位的操作都不予理睬
   
10. 
    
11. case NAND_CTL_SETCLE:
    
12. this->IO_ADDR_W = (void __iomem *) EMI_NAND_COM_RAW;
    
13. break;
    
14. //IO_ADDR_W是nand flash的数据寄存器地址。是_iomem类型变量(这是个空的宏定义，
    
15. //但这样可以让人很容易知道这是个寄存器变量。)，这里的作用是将EMI_NAND_COM_RAW即nand flash
    
16. //内存的地址赋值给IO_ADDR_W,这样后面的操作，在使用IO_ADDR_W时就是使用EMI_NAND_COM_RAW。
    
17. 
    
18. case NAND_CTL_SETALE:
    
19. this->IO_ADDR_W = (void __iomem *) EMI_NAND_ADDR1_RAW;
    
20. break;
    
21. 
    
22. case NAND_READ_ID:
    
23. this->IO_ADDR_R = (void __iomem *) EMI_NAND_ID_RAW;
    
24. break;
    
25. 
    
26. case NAND_READ_STATUS:
    
27. this->IO_ADDR_R = (void __iomem *) EMI_NAND_STA_RAW;
    
28. break;
    
29. 
    
30. /* NAND_CTL_CLRCLE: */
    
31. /* NAND_CTL_CLRALE: */
    
32. default:
    
33. this->IO_ADDR_W = (void __iomem *) EMI_NAND_DATA_RAW;
    
34. this->IO_ADDR_R = (void __iomem *) EMI_NAND_DATA_RAW;
    
35. //在一些命令使能和地址使能后，将IO_ADDR_W还原成EMI_NAND_DATA_RAW nand flash数据寄存器地址
    
36. break;
    
37. }
    
38. }

this->read_buf(mtd, data_poi, end);read_buf指向的函数为sep4020_nand_read_buf，

点击(此处)折叠或打开

1. static void sep4020_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
   
2. {
   
3. int i;
   
4. struct nand_chip *this = mtd->priv;
   
5. //配置DMAC用于nand的传输
   
6. DMAC_C0CONTROL = ((2112>>2)<<14) + (1<<13) + (2<<9) +(2<<6) + (3<<3) + 3;
   
7. DMAC_C0SRCADDR = EMI_NAND_DATA_RAW ;
   
8. DMAC_C0DESTADD = vaddr; //vaddr在board_nand_init函数中，使用malloc分配的一块2112大的内存空间
   
9. DMAC_C0CONFIGURATION = 0x31d ;
   
10. EMI_NAND_COM = 0xc0003000; //nand命令控制器，00 30读命令，且最高位使能nand控制器，开始读数据。
    
11. while(1)
    
12. {
    
13. if ((EMI_NAND_IDLE & 0x01) != 0)
    
14. break;
    
15. }
    
16. if(len == 2048 || len == 2112) //如果要读取的长度是1页或包含oob的1页。则从vaddr开始复制len长度的数据
    
17. {
    
18. memcpy(buf,vaddr,len);
    
19. }
    
20. else if(len == 64) //如果读取的长度是64，则是要只读取oob区域，则从vaddr+2048地址处开始复制。
    
21. {
    
22. memcpy(buf,vaddr+2048,len);
    
23. }
    
24. }

这个函数使能了nand flash控制器，将nandflash中对于的一页数据读出，并将适当的数据复制给了参数传来的buf。

nand read命令大致就是这样一个流程。本来想只是写写uboot关于nand的处理，和这个sep4020 nand控制器的特点。没想到这个版本的uboot就是nand驱动和内核的差不多，代码量太多。可能也是自己不熟悉这块，陆陆续续写了几天，感觉写的效率很低，写的想吐。于是草草结尾。之后看看其他版本的uboot的nand相关，不知道还是不是这样了。