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. /* Checkfor 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 lockand see if the deviceis 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. /* Deselectand 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 incase 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 isnot 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, checkfor bad block(s). Stayin the
    
53. * loop to be sure if the offset changes because of
    
54. * a bad block, that thenext block that will be
    
55. * written tois also checked. Thus avoiding errorsif
    
56. * the block(s) after the skipped block(s)is also bad
    
57. * (number of blocks dependingon 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 blocksin an erase blockfor
    
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 datato 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_tlen, 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: offsetto read from
   
5. * @len: number of bytesto read
   
6. * @retlen: pointerto variable to store the number of read bytes
   
7. * @buf: the databufferto 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_tlen,
    
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 lockand see if the deviceis 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 readis not page aligned, we haveto 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, Readin 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: Readin 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 needto 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 calcerror correction directly, it checks the hw
     
149. * generator for anerror, reads back the syndromeand
     
150. * does the error correctionon 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 delayor 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. /* Deselectand 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 == desiredlen 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相关，不知道还是不是这样了。