使uboot支持write.yaffs功能

原文地址：http://blog.csdn.net/linucos/article/details/5429013

本文针对uboot较新版本uboot-2009进行，nand flash page(512+16)，

方法：跟踪nand write命令即可，需要修改一定是沿途被调用过的命令

uboot本身并没有支持yaffs文件系统烧写，在此我们自己添加：

1.命令部分

common/cmd_nand.c

U_BOOT_CMD(nand, CONFIG_SYS_MAXARGS, 1, do_nand,
 "NAND sub-system",
 "info - show available NAND devices/n"
 "nand device [dev] - show or set current device/n"
 "nand read - addr off|partition size/n"
 "nand write - addr off|partition size/n"
 "    read/write 'size' bytes starting at offset 'off'/n"
 "    to/from memory address 'addr', skipping bad blocks./n"
 "nand erase [clean] [off size] - erase 'size' bytes from/n"
 "    offset 'off' (entire device if not specified)/n"
#if defined(ENABLE_CMD_NAND_YAFFS)
 "nand read[.yaffs[1]] is not provide temporarily!/n"
 "nand write[.yaffs[1]]    addr off size - write the `size' byte yaffs image starting/n"
 "     at offset `off' from memory address `addr' (.yaffs1 for 512+16 NAND)/n"
#endif
 "nand bad - show bad blocks/n"
 "nand dump[.oob] off - dump page/n"
 "nand scrub - really clean NAND erasing bad blocks (UNSAFE)/n"
 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)/n"
 "nand biterr off - make a bit error at offset (UNSAFE)"
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
 "/n"
 "nand lock [tight] [status]/n"
 "    bring nand to lock state or display locked pages/n"
 "nand unlock [offset] [size] - unlock section"
#endif
);

2.源码部分

common/cmd_nand.c

函数：do_nand()

 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
  int read;

  if (argc < 4)
   goto usage;

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

  read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
  printf("/nNAND %s: ", read ? "read" : "write");
  if (arg_off_size(argc - 3, argv + 3, nand, &off, &size) != 0)
   return 1;

  s = strchr(cmd, '.');
  if (!s || !strcmp(s, ".jffs2") ||
      !strcmp(s, ".e") || !strcmp(s, ".i")) {
   if (read)
    ret = nand_read_skip_bad(nand, off, &size,
        (u_char *)addr);
   else
    ret = nand_write_skip_bad(nand, off, &size,
         (u_char *)addr);
#if defined(ENABLE_CMD_NAND_YAFFS)
  }else if ( s != NULL &&
   (!strcmp(s, ".yaffs") || !strcmp(s, ".yaffs1"))){
       if(read)  {
      printf("nand read.yaffs[1] is not provide temporarily!"); 
       } else    {
    nand->rw_oob = 1;
#if defined(ENABLE_CMD_NAND_YAFFS_SKIPFB)
    nand->skipfirstblk = 1;
#else
    nand->skipfirstblk = 0; 
#endif
    ret = nand_write_skip_bad(nand,off,&size,(u_char *)addr);
#if defined(ENABLE_CMD_NAND_YAFFS_SKIPFB)
    nand->skipfirstblk = 0;
#endif
    nand->rw_oob = 0;
       }
#endif
  } else if (!strcmp(s, ".oob")) {
   /* out-of-band data */
   mtd_oob_ops_t ops = {
    .oobbuf = (u8 *)addr,
    .ooblen = size,
    .mode = MTD_OOB_RAW
   };

   if (read)
    ret = nand->read_oob(nand, off, &ops);
   else
    ret = nand->write_oob(nand, off, &ops);
  } else {
   printf("Unknown nand command suffix '%s'./n", s);
   return 1;
  }

  printf(" %zu bytes %s: %s/n", size,
         read ? "read" : "written", ret ? "ERROR" : "OK");

  return ret == 0 ? 0 : 1;
 }

---------------------------------------------------------------------------------------------------------------------------------

include/linux/mtd/mtd.h

struct mtd_info {
 u_char type;
 u_int32_t flags;
 uint64_t size;  /* Total size of the MTD */

 /* "Major" erase size for the device. Na飗e users may take this
  * to be the only erase size available, or may use the more detailed
  * information below if they desire
  */
 u_int32_t erasesize;
 /* Minimal writable flash unit size. In case of NOR flash it is 1 (even
  * though individual bits can be cleared), in case of NAND flash it is
  * one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
  * it is of ECC block size, etc. It is illegal to have writesize = 0.
  * Any driver registering a struct mtd_info must ensure a writesize of
  * 1 or larger.
  */
 u_int32_t writesize;

#if defined(ENABLE_CMD_NAND_YAFFS)
  /*Thanks for hugerat's code*/
 u_char rw_oob;
 u_char skipfirstblk;
#endif

 u_int32_t oobsize;   /* Amount of OOB data per block (e.g. 16) */
 u_int32_t oobavail;  /* Available OOB bytes per block */

 /* Kernel-only stuff starts here. */
 const char *name;
 int index;

 /* ecc layout structure pointer - read only ! */
 struct nand_ecclayout *ecclayout;

 /* Data for variable erase regions. If numeraseregions is zero,
  * it means that the whole device has erasesize as given above.
  */
 int numeraseregions;
 struct mtd_erase_region_info *eraseregions;
------------------------------------------------------------------------------------------------------------------------------

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;
#if defined(ENABLE_CMD_NAND_YAFFS)
 int oldopsmode = 0;
 if(mtd->rw_oob==1) {
  size_t oobsize = mtd->oobsize;  
  size_t datasize = mtd->writesize;
  int i = 0;
  uint8_t oobtemp[oobsize];
  int datapages = 0;
  datapages = len/(datasize); 
  for(i=0;i<(datapages);i++) {
   memcpy((void *)oobtemp,
    (void *)(buf+datasize*(i+1)),
    oobsize);
   memmove((void *)(buf+datasize*(i+1)),
    (void *)(buf+datasize*(i+1)+oobsize),
    (datapages-(i+1))*(datasize)+(datapages-1)*oobsize);
   memcpy((void *)(buf+(datapages)*(datasize+oobsize)-oobsize),
    (void *)(oobtemp),
    oobsize);
  }
 }
#endif
 /* Do not allow reads past end of device */
 if ((to + len) > mtd->size)
  return -EINVAL;
 if (!len)
  return 0;

 nand_get_device(chip, mtd, FL_WRITING);

 chip->ops.len = len;
 chip->ops.datbuf = (uint8_t *)buf;

#if defined(ENABLE_CMD_NAND_YAFFS)
 if(mtd->rw_oob!=1) {
   chip->ops.oobbuf = NULL;
 } else {
   chip->ops.oobbuf = (uint8_t *)(buf+len); 
   chip->ops.ooblen = mtd->oobsize;
   oldopsmode = chip->ops.mode;
   chip->ops.mode = MTD_OOB_RAW; 
 }
#else
 chip->ops.oobbuf = NULL;
#endif
 ret = nand_do_write_ops(mtd, to, &chip->ops);

 *retlen = chip->ops.retlen;

 nand_release_device(mtd);

#if defined(ENABLE_CMD_NAND_YAFFS)
 chip->ops.mode = oldopsmode; 
#endif
 return ret;
}

--------------------------------------------------------------------------------------------------------------------

drivers/mtd/nand/nand_util.c

int nand_write_skip_bad(nand_info_t *nand, loff_t offset, size_t *length,
   u_char *buffer)
{
 int rval;
 size_t left_to_write = *length;
 size_t len_incl_bad;
 u_char *p_buffer = buffer;
#if defined(ENABLE_CMD_NAND_YAFFS)
 if(nand->rw_oob==1) {
  size_t oobsize = nand->oobsize;  
  size_t datasize = nand->writesize;
  int datapages = 0;

  if (((*length)%(nand->oobsize+nand->writesize)) != 0) {
      printf ("Attempt to write error length data!/n");
      return -EINVAL;
     }

  datapages = *length/(datasize+oobsize);
  *length = datapages*datasize;
  left_to_write = *length;
//  nand->skipfirstblock=1;
 }
#endif

 /* Reject writes, which are not page aligned */
 if ((offset & (nand->writesize - 1)) != 0 ||
     (*length & (nand->writesize - 1)) != 0) {
  printf ("Attempt to write non page aligned data/n");
  return -EINVAL;
 }

 len_incl_bad = get_len_incl_bad (nand, offset, *length);

 if ((offset + len_incl_bad) > nand->size) {
  printf ("Attempt to write outside the flash area/n");
  return -EINVAL;
 }
 
#if !defined(ENABLE_CMD_NAND_YAFFS)
 if (len_incl_bad == *length) {
  rval = nand_write (nand, offset, length, buffer);
  if (rval != 0)
   printf ("NAND write to offset %llx failed %d/n",
    offset, rval);

  return rval;
 }
#endif
 while (left_to_write > 0) {
  size_t block_offset = offset & (nand->erasesize - 1);
  size_t 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 defined(ENABLE_CMD_NAND_YAFFS)
  if(nand->skipfirstblk==1) {  
   nand->skipfirstblk=0;
   printf ("Skip the first good block %llx/n",
    offset & ~(nand->erasesize - 1));
   offset += nand->erasesize - block_offset;
   continue;
  }
#endif
  if (left_to_write < (nand->erasesize - block_offset))
   write_size = left_to_write;
  else
   write_size = nand->erasesize - block_offset;
  printf("/rWriting at 0x%llx -- ",offset); /*Thanks for hugerat's code*/
  rval = nand_write (nand, offset, &write_size, p_buffer);
  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;
  printf("%d%% is complete.",100-(left_to_write/(*length/100)));/*Thanks for hugerat's code*/
  offset        += write_size;
#if defined(ENABLE_CMD_NAND_YAFFS)
  if(nand->rw_oob==1) {
   p_buffer += write_size+(write_size/nand->writesize*nand->oobsize);
  } else {
   p_buffer += write_size;
  }
#else
  p_buffer      += write_size;
#endif
 }

 return 0;
}

3.添加配置

为了支持write.yaffs命令，在板子的配置头文件中添加：

#define ENABLE_CMD_NAND_YAFFS 1

#define ENABLE_CMD_NAND_YAFFS_SKIPFB 1

即可

4.使用

烧写yaffs文件系统时，只要nand write.yaffs 即可