u-boot的nand驱动写过程分析

从命令说起，在u-boot输入下列命令：

nand write 40008000 0 20000
命令的意思是将内存0x40008000开始的部分写入nand，从nand地址0开始写，写入长度是0x200000

回车之后，代码如何运行呢？命令的输入，执行之前都已经分析过了，初始化过程也分析了

请参阅：

http://blog.csdn.net/andy_wsj/article/details/9335755

http://blog.csdn.net/andy_wsj/article/details/9339247

http://blog.csdn.net/andy_wsj/article/details/8614905

执行这条命令，将调用\u-boot-sunxi-sunxi\common\cmd_nand.c内的函数do_nand。

int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])

nand write 40008000 0 20000在参数argv中，而且

argv[0] = "nand"

argv[1] = "write"

argv[2] = "40008000"

argv[3] = "0"

argv[4] = "20000"

argc = 5 参数的个数

分析一下do_nand函数的片段，篇幅关系，只保留写操作部分：

nt do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])

{


int i, ret = 0;


ulong addr;


loff_t off, size;


char *cmd, *s;


nand_info_t *nand;

#ifdef CONFIG_SYS_NAND_QUIET


int quiet = CONFIG_SYS_NAND_QUIET;

#else


int quiet = 0;

#endif


const char *quiet_str = getenv("quiet");


int dev = nand_curr_device;                 //当前NAND芯片，如果板上有多个芯片，则不能直接赋值，大部分板子都是一个NAND


int repeat = flag & CMD_FLAG_REPEAT;

/* at least two arguments please */


if (argc < 2)


goto usage;

if (quiet_str)


quiet = simple_strtoul(quiet_str, NULL, 0) != 0;

cmd = argv[1];   //cmd就指向命令“write”，

........判断是什么命令，多余判断删除了..............

/* The following commands operate on the current device, unless


* overridden by a partition specifier.  Note that if somehow the


* current device is invalid, it will have to be changed to a valid


* one before these commands can run, even if a partition specifier


* for another device is to be used.


*/


if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||  //判断芯片是否存在或是否定义


   !nand_info[dev].name) {


puts("\nno devices available\n");


return 1;


}


nand = &nand_info[dev];   //获取定义的nand芯片信息

  

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

  


if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {  //nand读写操作


size_t rwsize;


ulong pagecount = 1;


int read;


int raw;

if (argc < 4)  


goto usage;

addr = (ulong)simple_strtoul(argv[2], NULL, 16);  //将argv[2] = "40008000"转换成16进制，0x40008000

read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */  //判断读写操作类型


printf("\nNAND %s: ", read ? "read" : "write");

nand = &nand_info[dev];

s = strchr(cmd, '.');   //看看是否带有扩展命令，如write.raw, write.jffs2等等，输入是“write”，结果s = NULL；

if (s && !strcmp(s, ".raw")) {


      ......省略.....


      


} else {  //执行这里，计算地址偏移量，长度


if (arg_off_size(argc - 3, argv + 3, &dev, 


&off, &size) != 0)


return 1;

rwsize = size;


}

if (!s || !strcmp(s, ".jffs2") ||      //实际执行这里


   !strcmp(s, ".e") || !strcmp(s, ".i")) {


if (read)


ret = nand_read_skip_bad(nand, off, &rwsize,


(u_char *)addr);


else


ret = nand_write_skip_bad(nand, off, &rwsize,   //执行函数nand_write_skip_bad


 (u_char *)addr, 0);

} else if (......省略.....) {


......省略.....


......省略.....

} else {


printf("Unknown nand command suffix '%s'.\n", s);


return 1;


}

printf(" %zu bytes %s: %s\n", rwsize,


      read ? "read" : "written", ret ? "ERROR" : "OK");

return ret == 0 ? 0 : 1;


}

..........

return 0;

}

来看看函数nand_write_skip_bad，在文件\u-boot-sunxi-sunxi\drivers\mtd\nand\nand_util.c内：

经过do_nand处理，可知参数就是输入命令的内容：

offset   为  0

*length  为 0x200000

buffer   指向0x40008000

int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,


u_char *buffer, int flags)

{


int rval = 0, blocksize;


size_t left_to_write = *length;


u_char *p_buffer = buffer;


int need_skip;

#ifdef CONFIG_CMD_NAND_YAFFS


if (flags & WITH_YAFFS_OOB) {


if (flags & ~WITH_YAFFS_OOB)


return -EINVAL;

int pages;


pages = nand->erasesize / nand->writesize;


blocksize = (pages * nand->oobsize) + nand->erasesize;


if (*length % (nand->writesize + nand->oobsize)) {


printf ("Attempt to write incomplete page"


" in yaffs mode\n");


return -EINVAL;


}


} else

#endif


{


blocksize = nand->erasesize;  //执行这里，nand的刷新都是以块为单位的，所以blocksize就是刷新的长度，对于cubieboard上的nand芯片，是1M+80K


}

/*


* nand_write() handles unaligned, partial page writes.


*


* We allow length to be unaligned, for convenience in


* using the $filesize variable.


*


* However, starting at an unaligned offset makes the


* semantics of bad block skipping ambiguous (really,


* you should only start a block skipping access at a


* partition boundary).  So don't try to handle that.


*/


if ((offset & (nand->writesize - 1)) != 0) {    //输入的偏移量要以块长度对齐


printf ("Attempt to write non page aligned data\n");


*length = 0;


return -EINVAL;


}

need_skip = check_skip_len(nand, offset, *length);  //判断是否需要越过坏块，这里需要坏块读取操作，nand驱动的一个功能


if (need_skip < 0) {


printf ("Attempt to write outside the flash area\n");


*length = 0;


return -EINVAL;


}

if (!need_skip && !(flags & WITH_DROP_FFS)) {        //不需要，即写的部分没有坏块


rval = nand_write (nand, offset, length, buffer);  //直接写


if (rval == 0)


return 0;

*length = 0;


printf ("NAND write to offset %llx failed %d\n",


offset, rval);


return rval;


}

while (left_to_write > 0) {  // 剩下要写的字节数，开始就是命令输入的0x200000


size_t block_offset = offset & (nand->erasesize - 1);


size_t write_size, truncated_write_size;

WATCHDOG_RESET ();

if (nand_block_isbad (nand, offset & ~(nand->erasesize - 1))) { //从开始的位置往后找坏块，直到找到一个可写的为止


printf ("Skip bad block 0x%08llx\n",


offset & ~(nand->erasesize - 1));


offset += nand->erasesize - block_offset;


continue;


}

if (left_to_write < (blocksize - block_offset))  //找到可写的块，判断写入的数据是不是小于一块，对于cubieboard，是1M


write_size = left_to_write;                    //由于输入的是0x200000即2M，因此需要写两次


else


write_size = blocksize - block_offset;

#ifdef CONFIG_CMD_NAND_YAFFS

.......

#endif


{


truncated_write_size = write_size;

#ifdef CONFIG_CMD_NAND_TRIMFFS

 .......

#endif

rval = nand_write(nand, offset, &truncated_write_size,  //调用nand_write，写入数据


p_buffer);


offset += write_size;         //偏移量往后移动


p_buffer += write_size;       //数据指针往后移动


}

if (rval != 0) {


printf ("NAND write to offset %llx failed %d\n",


offset, rval);


*length -= left_to_write;


return rval;


}

left_to_write -= write_size;   //剩下的字节数，循环写的条件


}

return 0;

}

无论如何写，有没有坏块，最后都使用函数nand_write，接下来再看看这个函数

在文件在文件\u-boot-sunxi-sunxi\drivers\mtd\nand\nand_base.c内：

这个函数就是写的准备，这已经执行到驱动代码的逻辑层了

static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,


 size_t *retlen, const uint8_t *buf)

{


struct nand_chip *chip = mtd->priv;


int ret;

/* Do not allow writes past end of device */ 不能超过最大长度


if ((to + len) > mtd->size)


return -EINVAL;


if (!len)


return 0;

nand_get_device(chip, mtd, FL_WRITING);  //获取设备，就是获取需要写的那个nand芯片的数据

chip->ops.len = len;                     //写入的长度，按输入命令，第一次时这个就是一个块的长度


chip->ops.datbuf = (uint8_t *)buf;       //数据所在的位置，第一次就是输入的内存地址0x40008000处


chip->ops.oobbuf = NULL;

ret = nand_do_write_ops(mtd, to, &chip->ops);   //执行写操作

*retlen = chip->ops.retlen;

nand_release_device(mtd);

return ret;

}

再看看nand_do_write_ops函数，就在这个文件nand_base.c内，nand_write函数的上面：

到了这里，其实已经接近硬件操作了，如果要写一个nand驱动，实现写操作，

看看这个函数，就是知道需要实现的几个操作了。下面对几个关键的地方进行标记，说明写驱动需要实现的功能

static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,


    struct mtd_oob_ops *ops)

{


int chipnr, realpage, page, blockmask, column;


struct nand_chip *chip = mtd->priv;


uint32_t writelen = ops->len;

uint32_t oobwritelen = ops->ooblen;


uint32_t oobmaxlen = ops->mode == MTD_OOB_AUTO ?


mtd->oobavail : mtd->oobsize;

uint8_t *oob = ops->oobbuf;


uint8_t *buf = ops->datbuf;


int ret, subpage;

ops->retlen = 0;


if (!writelen)


return 0;

column = to & (mtd->writesize - 1);


subpage = column || (writelen & (mtd->writesize - 1));

if (subpage && oob)


return -EINVAL;

chipnr = (int)(to >> chip->chip_shift);


chip->select_chip(mtd, chipnr);          //芯片片选，由于各种CPU的片选方式或寄存器不同，或者板子电路不同，所以用户必须自己实现这个函数

/* Check, if it is write protected */


if (nand_check_wp(mtd)) {


printk (KERN_NOTICE "nand_do_write_ops: Device is write protected\n");


return -EIO;


}

realpage = (int)(to >> chip->page_shift);


page = realpage & chip->pagemask;


blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;

/* Invalidate the page cache, when we write to the cached page */


if (to <= (chip->pagebuf << chip->page_shift) &&


   (chip->pagebuf << chip->page_shift) < (to + ops->len))


chip->pagebuf = -1;

/* If we're not given explicit OOB data, let it be 0xFF */


if (likely(!oob))


memset(chip->oob_poi, 0xff, mtd->oobsize);

/* Don't allow multipage oob writes with offset */


if (oob && ops->ooboffs && (ops->ooboffs + ops->ooblen > oobmaxlen))


return -EINVAL;

while (1) {    输入的长度是块，只能一页一页的写，所以要循环写


WATCHDOG_RESET();

int bytes = mtd->writesize;


int cached = writelen > bytes && page != blockmask;


uint8_t *wbuf = buf;

/* Partial page write ? */


if (unlikely(column || writelen < (mtd->writesize - 1))) {


cached = 0;


bytes = min_t(int, bytes - column, (int) writelen);


chip->pagebuf = -1;


memset(chip->buffers->databuf, 0xff, mtd->writesize);


memcpy(&chip->buffers->databuf[column], buf, bytes);


wbuf = chip->buffers->databuf;


}

if (unlikely(oob)) {


size_t len = min(oobwritelen, oobmaxlen);


oob = nand_fill_oob(chip, oob, len, ops);


oobwritelen -= len;


}

ret = chip->write_page(mtd, chip, wbuf, page, cached,  //写一页，这个函数有通用的实现，若不适合自己的芯片，则需要自己实现页写功能


      (ops->mode == MTD_OOB_RAW));


if (ret)


break;

writelen -= bytes;


if (!writelen)


break;

column = 0;


buf += bytes;


realpage++;

page = realpage & chip->pagemask;


/* Check, if we cross a chip boundary */


if (!page) {


chipnr++;


chip->select_chip(mtd, -1);


chip->select_chip(mtd, chipnr);


}


}

ops->retlen = ops->len - writelen;


if (unlikely(oob))


ops->oobretlen = ops->ooblen;


return ret;

}

再看看通用的页写函数

在函数int nand_scan_tail(struct mtd_info *mtd)内有两句代码：

......


if (!chip->write_page)


chip->write_page = nand_write_page;

......

如果用户没初始化页写函数，则使用默认函数nand_write_page，这就是需要分析的函数

static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,


  const uint8_t *buf, int page, int cached, int raw)

{


int status;

chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);   //命令函数也有默认版本，对单次写地址的芯片如2440，6410，可以使用默认函数，但是不适合A10

                                                    //A10的地址是两个寄存器，每个32位，理论可以支持64位的地址宽度

                                                    //这里执行nand命令NAND_CMD_SEQIN，值是0x80


if (unlikely(raw))                                //观察调用的地方，可以看出 raw = 2    ===>  ops->mode == MTD_OOB_RAW 


chip->ecc.write_page_raw(mtd, chip, buf);       //ecc模块也有默认实现


else


chip->ecc.write_page(mtd, chip, buf);

/*


* Cached progamming disabled for now, Not sure if its worth the


* trouble. The speed gain is not very impressive. (2.3->2.6Mib/s)


*/


cached = 0;

if (!cached || !(chip->options & NAND_CACHEPRG)) {

chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);   ////这里执行nand命令NAND_CMD_PAGEPROG，值是0x10


status = chip->waitfunc(mtd, chip);               //等待写完成，这个需要用自己实现


* See if operation failed and additional status checks are


* available


*/


if ((status & NAND_STATUS_FAIL) && (chip->errstat))


status = chip->errstat(mtd, chip, FL_WRITING, status,


      page);

if (status & NAND_STATUS_FAIL)


return -EIO;


} else {


chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1);


status = chip->waitfunc(mtd, chip);


}

#ifdef CONFIG_MTD_NAND_VERIFY_WRITE


/* Send command to read back the data */


chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);

if (chip->verify_buf(mtd, buf, mtd->writesize))


return -EIO;

#endif


return 0;

}

再看看默认的chip->ecc.write_page_raw函数干了什么事情

在函数int nand_scan_tail(struct mtd_info *mtd)内有两句代码：

......


if (!chip->ecc.write_page_raw)


chip->ecc.write_page_raw = nand_write_page_raw;

......

如果用户没初始化页写函数，则使用默认函数nand_write_page_raw，这就是需要分析的函数

这个函数将数据写入，写入什么位置呢？还要看看它调用的函数chip->write_buf

static void nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,


const uint8_t *buf)

{


chip->write_buf(mtd, buf, mtd->writesize); 


chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);

}

再看看默认的chip->write_buf函数

在函数int nand_scan_tail(struct mtd_info *mtd)内有两句代码：

......


if (!chip->write_buf)


chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;

......

如果用户没初始化页写函数，8位操作则使用默认函数nand_write_buf，16位操作则使用默认函数nand_write_buf16，

cubieboard使用的nand芯片是8位的，就看看nand_write_buf函数

void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)

{


int i;


struct nand_chip *chip = mtd->priv;

for (i = 0; i < len; i++)


writeb(buf[i], chip->IO_ADDR_W);

}

将数据写入寄存器chip->IO_ADDR_W，即写到nand缓存

从这里可以看出，上面的写操作过程就是：

命令0x80-->写数据-->命令0x10-->等待完成

查看cubieboard上面nand芯片K9GBG08U0A的数据手册，页写操作的过程真好相同，因此这个驱动可以使用

使用的前提就是需要实现一下几个函数：

片选函数：    chip->select_chip

命令操作函数：chip->cmdfunc

chip->waitfunc调用的两个函数:

芯片就绪函数：chip->dev_ready

字节读取函数：chip->read_byte

到这里，我都没有分析数据结构，只描述了调用流程

观察各个函数，贯穿整个过程的数据结构有两个

struct mtd_info

struct nand_chip

这两个数据结构在初始化分析时已经讲过了