uboot之nand flash相关(3)

310阅读　0评论2016-10-06　诺亚方舟破土巴郎
分类：LINUX

然后我们分析一下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;

  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;

  5.     if (!this->bbt)    //如果nand_chip结构体变量中的bbt（坏块标记表）表指针是空的
  6.         return this->block_bad(mtd, ofs, getchip);

  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;

  7.     page = (int)(ofs >> this->page_shift) & this->pagemask;            //(1)

  9.     if (getchip) {            //选中芯片
  10.         chipnr = (int)(ofs >> this->chip_shift);

  12.         /* Grab the lock and see if the device is available */
  13.         nand_get_device (this, mtd, FL_READING);

  15.         /* Select the NAND device */
  16.         this->select_chip(mtd, chipnr);
  17.     }

  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.     }

  32.     if (getchip) {
  33.         /* Deselect and wake up anyone waiting on the device */
  34.         nand_release_device(mtd);
  35.     }

  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;

  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)

  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);

  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;

  4.         if (argc < 4)
  5.             goto usage;

  7.         addr = (ulong)simple_strtoul(argv[2], NULL, 16);

  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;

  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.             }


  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.         }

  81.         printf(" %d bytes %s: %s\n", size,
  82.          read ? "read" : "written", ret ? "ERROR" : "OK");

  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;

  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.     }

  30.     pagelen = meminfo->oobblock
  31.         + ((opts->readoob != 0) ? meminfo->oobsize : 0);

  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.     }

  43.     if (!opts->quiet)
  44.         printf("\n");

  46.     /* get data from input and write to the device */
  47.     while (imglen && (mtdoffset < meminfo->size)) {

  49.         WATCHDOG_RESET ();

  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;

  64.             /* check all the blocks in an erase block for
  65.              * bad blocks */
  66.             do {
  67.                 int ret = meminfo->block_isbad(meminfo, offs);

  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.                 }

  83.                 if (baderaseblock) {
  84.                     mtdoffset = blockstart
  85.                         + meminfo->erasesize;
  86.                 }
  87.                 offs +=     meminfo->erasesize;

  89.             } while (offs < blockstart + meminfo->erasesize);
  90.         }


  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);

  100.         if (result != 0) {
  101.             printf("reading NAND page at offset 0x%lx failed\n",
  102.              mtdoffset);
  103.             return -1;
  104.         }

  106.         if (imglen < readlen) {
  107.             readlen = imglen;
  108.         }

  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);

  123.             if (result != 0) {
  124.                 printf("\nMTD readoob failure: %d\n",
  125.                  result);
  126.                 return -1;
  127.             }


  130.             if (imglen < readlen) {
  131.                 readlen = imglen;
  132.             }

  134.             memcpy(buffer, oob_buf, readlen);

  136.             buffer += readlen;
  137.             imglen -= readlen;
  138.         }

  140.         if (!opts->quiet) {
  141.             unsigned long long n = (unsigned long long)
  142.                  (opts->length-imglen) * 100;
  143.             int percent;

  145.             do_div(n, opts->length);
  146.             percent = (int)n;

  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.         }

  161.         mtdoffset += meminfo->oobblock;
  162.     }

  164.     if (!opts->quiet)
  165.         printf("\n");

  167.     if (imglen > 0) {
  168.         printf("Could not read entire image due to bad blocks\n");
  169.         return -1;
  170.     }

  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;


  31.     DEBUG (MTD_DEBUG_LEVEL3, "nand_read_ecc: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len);

  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.     }

  40.     /* Grab the lock and see if the device is available */
  41.     nand_get_device (this, mtd ,FL_READING);

  43.     /* use userspace supplied oobinfo, if zero */
  44.     if (oobsel == NULL)
  45.         oobsel = &mtd->oobinfo;

  47.     /* Autoplace of oob data ? Use the default placement scheme */
  48.     if (oobsel->useecc == MTD_NANDECC_AUTOPLACE)
  49.         oobsel = this->autooob;

  51.     eccmode = oobsel->useecc ? this->eccmode : NAND_ECC_NONE;
  52.     oob_config = oobsel->eccpos;

  54.     /* Select the NAND device */
  55.     chipnr = (int)(from >> this->chip_shift);
  56.     this->select_chip(mtd, chipnr);

  58.     /* First we calculate the starting page */
  59.     realpage = (int) (from >> this->page_shift);
  60.     page = realpage & this->pagemask;

  62.     /* Get raw starting column */
  63.     col = from & (mtd->oobblock - 1);

  65.     end = mtd->oobblock;
  66.     ecc = this->eccsize;
  67.     eccbytes = this->eccbytes;

  69.     if ((eccmode == NAND_ECC_NONE) || (this->options & NAND_HWECC_SYNDROME))
  70.         compareecc = 0;

  72.     oobreadlen = mtd->oobsize;
  73.     if (this->options & NAND_HWECC_SYNDROME)
  74.         oobreadlen -= oobsel->eccbytes;

  76.     /* Loop until all data read */
  77.     while (read < len) {

  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;

  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.         }

  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.         }

  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];

  112.         eccsteps = this->eccsteps;

  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.         }

  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;

  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);

  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.         }

  163.         /* read oobdata */
  164.         this->read_buf(mtd, &oob_data[mtd->oobsize - oobreadlen], oobreadlen);

  166.         /* Skip ECC check, if not requested (ECC_NONE or HW_ECC with syndromes) */
  167.         if (!compareecc)
  168.             goto readoob;

  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]];

  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]);

  178.             /* Get next chunk of ecc bytes */
  179.             j += eccbytes;

  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.             }

  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.         }

  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;

  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));

  238.         if (read == len)
  239.             break;

  241.         /* For subsequent reads align to page boundary. */
  242.         col = 0;
  243.         /* Increment page address */
  244.         realpage++;

  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.     }

  260.     /* Deselect and wake up anyone waiting on the device */
  261.     nand_release_device(mtd);

  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;

  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）,读命令。

  13.     this->hwcontrol(mtd, NAND_CTL_SETCLE);
  14.     //命令引脚使能

  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 */

  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.     //

  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相关，不知道还是不是这样了。


上一篇：uboot之nand flash相关(2)
下一篇：裸机实验之存储控制器