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

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