Chinaunix首页 | 论坛 | 博客

edaplayer的ChinaUnix博客

首页　| 　博文目录　| 　关于我

edaplayer

  • 博客访问： 480063
  • 博文数量： 100
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 955
  • 用 户 组： 普通用户
  • 注册时间： 2014-11-21 09:30
文章分类

全部博文（100）

文章存档

2017年（1）

2016年（16）

2015年（83）

我的朋友
最近访客
推荐博文
相关博文
u-boot nand mtd 总结

分类： 嵌入式

2015-09-11 19:28:53

首先看几个全局变量，这些全局变量记录了nand设备的信息，并提供了驱动操作接口。
本文是基于s5pv210的uboot撰写的，mtd框架是通用的，其他cpu也类似。

typedef struct mtd_info nand_info_t;//记住，nand_info_t 就是mtd_info 结构体
int nand_curr_device = -1;
nand_info_t nand_info[CFG_MAX_NAND_DEVICE];//CFG_MAX_NAND_DEVICE配置为1
static struct nand_chip nand_chip[CFG_MAX_NAND_DEVICE];

看程序首先从入口看，无论是uboot还是linux内核，所有的设备（包括实际或抽象的）操作，必须注册该设备，也就是进行设备结构体初始化。
nand驱动的入口就是nand_init。
nand_init->
nand_init_chip->
board_nand_init(nand);//读nand id，初始化nand结构体 nand->ecc nand操作函数，如果是id = d5，默认8bitecc，如果没有匹配的nand id，默认1bitecc

    if (nand_scan(mtd, 1) == 0) {
    
                ret = nand_scan_ident(mtd, maxchips);
        if (!ret)
            ret = nand_scan_tail(mtd);
    
add_mtd_device，这一步很关键了，mtd->write怎么来的就看这里了。

s5pv210烧写uboot、logo、内核等分区使用8bitecc，只有烧写yaffs使用1bitecc(通过命令nand write.OEMyaffs)。

 重新缕一下初始化流程：
先初始化nand_chip再初始化mtd（即nand_info），其中nand_init_chip把nand_chip挂在mtd->priv指针上， board_nand_init负责初始化nand_chip.ecc成员函数，nand_set_defaults(chip, busw);负责初始化mtd->priv（nand_chip）的剩余其他成员/函数，nand_scan_ident->nand_get_flash_type负责获取初始化部分mtd信息（大小、oobsize、writesize等），nand_scan_tail负责初始化mtd的第一层操作函数（write_oob等）和chip的write_page等函数。

带oob的读写操作:
oob操作通常是mtd_write_oob调用mtd->_write_oob或mtd->_read_oob函数,该函数读写页数据同时读写OOB。
nand_scan_tail函数初始化对_write_oob函数指针进行初始化：
    mtd->write_oob = nand_write_oob;
nand_write_oob_>nand_do_write_oob
初始化完整路线是    nand_init->nand_init_chip -> nand_scan>nand_scan_tail



点击(此处)折叠或打开

  1. void nand_init(void)
  2. {
  3.     int i;
  4.     unsigned int size = 0;
  5.     for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {
  6.         nand_init_chip(&nand_info[i], &nand_chip[i], base_address[i]);
  7.         size += nand_info[i].size;
  8.         if (nand_curr_device == -1)
  9.             nand_curr_device = i;
  10.     }
  11. #ifndef CONFIG_DIS_BOARD_INFO
  12.     printf("%d MB ", size / (1024 * 1024));

  14. #if defined(CFG_NAND_FLASH_BBT)
  15.     printf("(Flash Based BBT Enabled)");
  16. #endif

  18.     printf("\n");
  19. #endif /* CONFIG_DIS_BOARD_INFO */
  20. #ifdef CFG_NAND_SELECT_DEVICE
  21.     /*
  22.      * Select the chip in the board/cpu specific driver
  23.      */
  24.     board_nand_select_device(nand_info[nand_curr_device].priv, nand_curr_device);
  25. #endif
  26. }

点击(此处)折叠或打开

  1. static void nand_init_chip(struct mtd_info *mtd, struct nand_chip *nand,
  2.              ulong base_addr)
  3. {
  4.     mtd->priv = nand;

  6.     nand->IO_ADDR_R = nand->IO_ADDR_W = (void __iomem *)base_addr;
  7.     board_nand_init(nand);

  9.     if (nand_scan(mtd, 1) == 0) {
  10.         if (!mtd->name)
  11.             mtd->name = (char *)default_nand_name;

  13. #ifdef CONFIG_MTD_DEVICE
  14.         /*
  15.          * Add MTD device so that we can reference it later
  16.          * via the mtdcore infrastructure (e.g. ubi).
  17.          */
  18.         mtd->name = dev_name;
  19.         add_mtd_device(mtd);
  20. #endif
  21.     } else
  22.         mtd->name = NULL;

  24. }

点击(此处)折叠或打开

  1. int nand_scan(struct mtd_info *mtd, int maxchips)
  2. {
  3.     int ret;

  5. #if 0
  6.     /* Many callers got this wrong, so check for it for a while... */
  7.     if (!mtd->owner && caller_is_module()) {
  8.         printk(KERN_CRIT "nand_scan() called with NULL mtd->owner!\n");
  9.         BUG();
  10.     }
  11. #endif

  13.     ret = nand_scan_ident(mtd, maxchips);
  14.     if (!ret)
  15.         ret = nand_scan_tail(mtd);
  16.     return ret;
  17. }
nand_scan_ident负责扫描nand设备的id。

点击(此处)折叠或打开

  1. /**
  2.  * nand_scan_ident - [NAND Interface] Scan for the NAND device
  3.  * @mtd:     MTD device structure
  4.  * @maxchips:     Number of chips to scan for
  5.  *
  6.  * This is the first phase of the normal nand_scan() function. It
  7.  * reads the flash ID and sets up MTD fields accordingly.
  8.  *
  9.  * The mtd->owner field must be set to the module of the caller.
  10.  */
  11. int nand_scan_ident(struct mtd_info *mtd, int maxchips)
  12. {
  13.     int i, busw, nand_maf_id;
  14.     struct nand_chip *chip = mtd->priv;
  15.     struct nand_flash_dev *type;

  17.     /* Get buswidth to select the correct functions */
  18.     busw = chip->options & NAND_BUSWIDTH_16;
  19.     /* Set the default functions */
  20.     nand_set_defaults(chip, busw);

  22.     /* Read the flash type */
  23.     type = nand_get_flash_type(mtd, chip, busw, &nand_maf_id);

  25.     if (!type) {
  26.         // printk (KERN_WARNING "No NAND device found!!!\n");
  27.         chip->select_chip(mtd, -1);
  28.         return 1;
  29.     }

  31.     /* Check for a chip array */
  32.     for (i = 1; i < maxchips; i++) {
  33.         chip->select_chip(mtd, i);
  34.         /* Send the command for reading device ID */
  35.         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
  36.         /* Read manufacturer and device IDs */
  37.         if (nand_maf_id != chip->read_byte(mtd) ||
  38.          type->id != chip->read_byte(mtd))
  39.             break;
  40.     }
  41.     if (i > 1)
  42.         printk(KERN_INFO "%d NAND chips detected\n", i);

  44.     /* Store the number of chips and calc total size for mtd */
  45.     chip->numchips = i;
  46.     mtd->size = i * chip->chipsize;

  48.     return 0;
  49. }
nand_scan_tail用于检查mtd操作函数，如果之前在board_nand_init函数中没有初始化nand操作接口指针，则在会使用默认函数初始化nand操作指针。最后扫描坏块。

点击(此处)折叠或打开

  1. /**
     * nand_scan_tail - [NAND Interface] Scan for the NAND device
     * @mtd:        MTD device structure
     * @maxchips:        Number of chips to scan for
     *
     * This is the second phase of the normal nand_scan() function. It
     * fills out all the uninitialized function pointers with the defaults
     * and scans for a bad block table if appropriate.
     */
  2. int nand_scan_tail(struct mtd_info *mtd)
  3. {
  4.     int i;
  5.     struct nand_chip *chip = mtd->priv;

  7.     if (!(chip->options & NAND_OWN_BUFFERS))
  8.         chip->buffers = kmalloc(sizeof(*chip->buffers), GFP_KERNEL);
  9.     if (!chip->buffers)
  10.         return -ENOMEM;

  12.     /* Set the internal oob buffer location, just after the page data */
  13.     chip->oob_poi = chip->buffers->databuf + mtd->writesize;

  15.     /*
  16.      * If no default placement scheme is given, select an appropriate one
  17.      */
  18.     if (!chip->ecc.layout) {
  19.         switch (mtd->oobsize) {
  20.         case 8:
  21.             chip->ecc.layout = &nand_oob_8;
  22.             break;
  23.         case 16:
  24.             chip->ecc.layout = &nand_oob_16;
  25.             break;
  26.         case 64:
  27.             chip->ecc.layout = &nand_oob_64;
  28.             break;
  29.         case 128:
  30.             chip->ecc.layout = &nand_oob_128;
  31.             break;
  32.         case 218:
  33.             chip->ecc.layout = &nand_oob_218;
  34.             break;
  35.         default:
  36.             printk(KERN_WARNING "No oob scheme defined for "
  37.              "oobsize %d\n", mtd->oobsize);
  38.             BUG();
  39.         }
  40.     }

  42.     if (!chip->write_page)
  43.         chip->write_page = nand_write_page;

  45.     /*
  46.      * check ECC mode, default to software if 3byte/512byte hardware ECC is
  47.      * selected and we have 256 byte pagesize fallback to software ECC
  48.      */
  49.     if (!chip->ecc.read_page_raw)
  50.         chip->ecc.read_page_raw = nand_read_page_raw;
  51.     if (!chip->ecc.write_page_raw)
  52.         chip->ecc.write_page_raw = nand_write_page_raw;

  54.     switch (chip->ecc.mode) {
  55.     case NAND_ECC_HW:
  56.         /* Use standard hwecc read page function ? */
  57.         if (!chip->ecc.read_page)
  58.             chip->ecc.read_page = nand_read_page_hwecc;
  59.         if (!chip->ecc.write_page)
  60.             chip->ecc.write_page = nand_write_page_hwecc;
  61.         if (!chip->ecc.read_oob)
  62.             chip->ecc.read_oob = nand_read_oob_std;
  63.         if (!chip->ecc.write_oob)
  64.             chip->ecc.write_oob = nand_write_oob_std;

  66.     case NAND_ECC_HW_SYNDROME:
  67.         if (!chip->ecc.calculate || !chip->ecc.correct ||
  68.          !chip->ecc.hwctl) {
  69.             printk(KERN_WARNING "No ECC functions supplied, "
  70.              "Hardware ECC not possible\n");
  71.             BUG();
  72.         }
  73.         /* Use standard syndrome read/write page function ? */
  74.         if (!chip->ecc.read_page)
  75.             chip->ecc.read_page = nand_read_page_syndrome;
  76.         if (!chip->ecc.write_page)
  77.             chip->ecc.write_page = nand_write_page_syndrome;
  78.         if (!chip->ecc.read_oob)
  79.             chip->ecc.read_oob = nand_read_oob_syndrome;
  80.         if (!chip->ecc.write_oob)
  81.             chip->ecc.write_oob = nand_write_oob_syndrome;

  83.         if (mtd->writesize >= chip->ecc.size)
  84.             break;
  85.         printk(KERN_WARNING "%d byte HW ECC not possible on "
  86.          "%d byte page size, fallback to SW ECC\n",
  87.          chip->ecc.size, mtd->writesize);
  88.         chip->ecc.mode = NAND_ECC_SOFT;

  90.     case NAND_ECC_SOFT:
  91.         chip->ecc.calculate = nand_calculate_ecc;
  92.         chip->ecc.correct = nand_correct_data;
  93.         chip->ecc.read_page = nand_read_page_swecc;
  94.         chip->ecc.write_page = nand_write_page_swecc;
  95.         chip->ecc.read_oob = nand_read_oob_std;
  96.         chip->ecc.write_oob = nand_write_oob_std;
  97.         chip->ecc.size = 256;
  98.         chip->ecc.bytes = 3;
  99.         break;

  101.     case NAND_ECC_NONE:
  102.         printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
  103.          "This is not recommended !!\n");
  104.         chip->ecc.read_page = nand_read_page_raw;
  105.         chip->ecc.write_page = nand_write_page_raw;
  106.         chip->ecc.read_oob = nand_read_oob_std;
  107.         chip->ecc.write_oob = nand_write_oob_std;
  108.         chip->ecc.size = mtd->writesize;
  109.         chip->ecc.bytes = 0;
  110.         break;

  112.     default:
  113.         printk(KERN_WARNING "Invalid NAND_ECC_MODE %d\n",
  114.          chip->ecc.mode);
  115.         BUG();
  116.     }

  118.     /*
  119.      * The number of bytes available for a client to place data into
  120.      * the out of band area
  121.      */
  122.     chip->ecc.layout->oobavail = 0;
  123.     for (i = 0; chip->ecc.layout->oobfree[i].length; i++)
  124.         chip->ecc.layout->oobavail +=
  125.             chip->ecc.layout->oobfree[i].length;

  127.     /*
  128.      * Set the number of read / write steps for one page depending on ECC
  129.      * mode
  130.      */
  131.     chip->ecc.steps = mtd->writesize / chip->ecc.size;
  132.     if(chip->ecc.steps * chip->ecc.size != mtd->writesize) {
  133.         printk(KERN_WARNING "Invalid ecc parameters\n");
  134.         BUG();
  135.     }
  136.     chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;

  138.     /*
  139.      * Allow subpage writes up to ecc.steps. Not possible for MLC
  140.      * FLASH.
  141.      */
  142.     if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&
  143.      !(chip->cellinfo & NAND_CI_CELLTYPE_MSK)) {
  144.         switch(chip->ecc.steps) {
  145.         case 2:
  146.             mtd->subpage_sft = 1;
  147.             break;
  148.         case 4:
  149.         case 8:
  150.             mtd->subpage_sft = 2;
  151.             break;
  152.         }
  153.     }
  154.     chip->subpagesize = mtd->writesize >> mtd->subpage_sft;

  156. /* XXX U-BOOT XXX */
  157. #if 0
  158.     /* Initialize state */
  159.     chip->state = FL_READY;
  160. #endif

  162.     /* De-select the device */
  163.     chip->select_chip(mtd, -1);

  165.     /* Invalidate the pagebuffer reference */
  166.     chip->pagebuf = -1;

  168.     /* Fill in remaining MTD driver data */
  169.     mtd->type = MTD_NANDFLASH;
  170.     mtd->flags = MTD_CAP_NANDFLASH;
  171.     mtd->ecctype = MTD_ECC_SW;
  172.     mtd->erase = nand_erase;
  173.     mtd->point = NULL;
  174.     mtd->unpoint = NULL;
  175.     mtd->read = nand_read;
  176.     mtd->write = nand_write;
  177.     mtd->read_oob = nand_read_oob;
  178.     mtd->write_oob = nand_write_oob;
  179.     mtd->sync = nand_sync;
  180.     mtd->lock = NULL;
  181.     mtd->unlock = NULL;
  182.     mtd->suspend = nand_suspend;
  183.     mtd->resume = nand_resume;
  184.     mtd->block_isbad = nand_block_isbad;
  185.     mtd->block_markbad = nand_block_markbad;

  187.     /* propagate ecc.layout to mtd_info */
  188.     mtd->ecclayout = chip->ecc.layout;

  190.     /* Check, if we should skip the bad block table scan */
  191.     if (chip->options & NAND_SKIP_BBTSCAN)
  192.         return 0;

  194.     /* Build bad block table */
  195.     return chip->scan_bbt(mtd);
  196. }

烧写uboot、logo、内核等分区使用8bitecc，只有烧写yaffs使用1bitecc(tftp烧写通过nand write.yaffs，SD卡烧写通过命令nand write.OEMyaffs)。

点击(此处)折叠或打开

  1. static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
  2.              const uint8_t *buf, int page, int cached, int raw)
  3. {
  4.     int status;

  6.     chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);

  8. /* jsgood: org: #else block only */
  9. #if defined(CONFIG_NAND_BL1_8BIT_ECC) && \
  10.         (defined(CONFIG_S3C6430) || \
  11.          defined(CONFIG_S3C2450) || \
  12.          defined(CONFIG_S3C2416) || \
  13.          defined(CONFIG_S5PC100) || \
  14.          defined(CONFIG_S5PC110) || \
  15.          defined(CONFIG_S5PV210) || \
  16.          defined(CONFIG_S5P6440))
  17. #ifdef CONFIG_TQ210
  18.     if ((mtd->writesize == 512 && page < 512) || (mtd->writesize == 2048 && page < 256) ||
  19.         (mtd->writesize == 4096 && page < 128)) {
  20. #else
  21.     if (page < CFG_NAND_PAGES_IN_BLOCK) {
  22. #endif
  23.         memset(chip->oob_poi, 0xff, mtd->oobsize);
  24.         s3c_nand_write_page_8bit(mtd, chip, buf);//烧写bootloader
  25.     } else
  26. #elif defined(CONFIG_NAND_BL1_8BIT_ECC) && defined(CONFIG_S3C6410)
  27.     if (page < CFG_NAND_PAGES_IN_BLOCK) {
  28.         memset(chip->oob_poi, 0xff, mtd->oobsize);
  29.         s3c_nand_write_page_8bit_for_irom(mtd, chip, buf);
  30.     } else
  31. #endif
  32.     {
  33.         if (unlikely(raw))
  34.             chip->ecc.write_page_raw(mtd, chip, buf);
  35.         else
  36.             chip->ecc.write_page(mtd, chip, buf);//烧写其他分区使用1bitecc
  37.     }
实际上烧写u-boot是使用nand_block_write这个函数烧写的。

点击(此处)折叠或打开

  1. //nand_block_write is used to write u-boot
  2. int nand_block_write(struct mtd_info *mtd, loff_t to, size_t len,
  3.         size_t *retlen, const u_char * buf)
  4. {
  5.     struct nand_chip *this = mtd->priv;
  6.     int eraseshift = this->phys_erase_shift;
  7.     int blocks = len >> eraseshift;
  8.     int blocksize = (1 << eraseshift);
  9.     loff_t ofs;
  10.     size_t _retlen = 0;
  11.     int ret;
  12. #if (defined(CONFIG_S5PC110) || defined(CONFIG_S5PV210)) && defined(CONFIG_EVT1) && !defined(CONFIG_FUSED) && !defined(CONFIG_SECURE)
  13.     int i;
  14.     ulong checksum;
  15.     uint8_t *ptr;
  16. #endif

  18.     ofs = to;

  20.     if (ofs & (blocksize - 1)) {
  21.         printk(" ERROR: Starting address 0x%x is not a block start address\n",
  22.                 (unsigned int) ofs);
  23.         return 1;
  24.     }
  25.     if (len & (blocksize - 1)) {
  26.         printk(" ERROR: Length (0x%x) is not block aligned\n", (unsigned int) len);
  27.         return 1;
  28.     }
  29.     printk("Main area read (%d blocks):\n", blocks);

  31. #if (defined(CONFIG_S5PC110) || defined(CONFIG_S5PV210)) && defined(CONFIG_EVT1) && !defined(CONFIG_FUSED) && !defined(CONFIG_SECURE)
  32.     if (to == 0) {
  33.         ptr = buf + 16;
  34.         for(i = 16, checksum = 0; i < 8192; i++) {
  35.             checksum += *ptr;
  36.             ptr++;
  37.         }
  38.         *((volatile u32 *)(buf + 0x8)) = checksum;
  39.         printk("Checksum is calculated.\n");
  40.     }

  42. #endif
  43.     printk("Main area write (%d blocks):\n", blocks);
  44.     *retlen = 0;

  46.     while (blocks) {
  47.         ret = mtd->block_isbad(mtd, ofs);
  48.         if (ret) {
  49.             printk("Bad blocks %d at 0x%x is skipped\n",
  50.              (u32)(ofs >> eraseshift), (u32)ofs);
  51.             goto next;
  52.         }

  54.         ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
  55.         if (ret) {
  56.             printk("Write failed 0x%x, %d", (u32)ofs, ret);
  57.             goto next;
  58.         }

  60.         buf += blocksize;
  61.         blocks--;
  62.         *retlen += _retlen;
  63. next:
  64.         ofs += blocksize;
  65.     }

  67.     return 0;
  68. }
注意ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
为什么mtd->write就是8bitecc烧写？这就回头看当初注册mtd的代码了。
在nand_scan_tail函数最后有一句    mtd->write = nand_write;
nand_write调用nand_do_write_ops

点击(此处)折叠或打开

  1. /**
  2.  * nand_do_write_ops - [Internal] NAND write with ECC
  3.  * @mtd:    MTD device structure
  4.  * @to:        offset to write to
  5.  * @ops:    oob operations description structure
  6.  *
  7.  * NAND write with ECC
  8.  */
  9. static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
  10.              struct mtd_oob_ops *ops)
  11. {
  12.     int chipnr, realpage, page, blockmask, column;
  13.     struct nand_chip *chip = mtd->priv;
  14.     uint32_t writelen = ops->len;
  15.     uint8_t *oob = ops->oobbuf;
  16.     uint8_t *buf = ops->datbuf;
  17.     int ret, subpage;
  18. #if 0
  19.     /* jsgood */
  20.     int percent = 0;
  21.     int percent_complete = 0;
  22. #endif
  23.     ops->retlen = 0;
  24.     if (!writelen)
  25.         return 0;

  27.     /* reject writes, which are not page aligned */
  28.     if (NOTALIGNED(to) || NOTALIGNED(ops->len)) {
  29.         printk(KERN_NOTICE "nand_write: "
  30.          "Attempt to write not page aligned data\n");
  31.         return -EINVAL;
  32.     }

  34.     column = to & (mtd->writesize - 1);
  35.     subpage = column || (writelen & (mtd->writesize - 1));

  37.     if (subpage && oob)
  38.         return -EINVAL;

  40.     chipnr = (int)(to >> chip->chip_shift);
  41.     chip->select_chip(mtd, chipnr);

  43.     /* Check, if it is write protected */
  44.     if (nand_check_wp(mtd))
  45.         return -EIO;

  47.     realpage = (int)(to >> chip->page_shift);
  48.     page = realpage & chip->pagemask;
  49.     blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;

  51.     /* Invalidate the page cache, when we write to the cached page */
  52.     if (to <= (chip->pagebuf << chip->page_shift) &&
  53.      (chip->pagebuf << chip->page_shift) < (to + ops->len))
  54.         chip->pagebuf = -1;

  56.     /* If we're not given explicit OOB data, let it be 0xFF */
  57.     if (likely(!oob))
  58.         memset(chip->oob_poi, 0xff, mtd->oobsize);

  60.     while(1) {
  61.         int bytes = mtd->writesize;
  62.         int cached = writelen > bytes && page != blockmask;
  63.         uint8_t *wbuf = buf;

  65.         /* Partial page write ? */
  66.         if (unlikely(column || writelen < (mtd->writesize - 1))) {
  67.             cached = 0;
  68.             bytes = min_t(int, bytes - column, (int) writelen);
  69.             chip->pagebuf = -1;
  70.             memset(chip->buffers->databuf, 0xff, mtd->writesize);
  71.             memcpy(&chip->buffers->databuf[column], buf, bytes);
  72.             wbuf = chip->buffers->databuf;
  73.         }

  75.         if (unlikely(oob))
  76.             oob = nand_fill_oob(chip, oob, ops);

  78.         ret = chip->write_page(mtd, chip, wbuf, page, cached,
  79.                  (ops->mode == MTD_OOB_RAW));
  80.         if (ret)
  81.             break;

  83.         writelen -= bytes;
  84. #if 0
  85.         /* jsgood */
  86.         percent = ((ops->len - writelen) * 100) / ops->len;

  88.         if (percent != percent_complete) {
  89.             printf("\rWriting page at 0x%x -- %d%% complete.", page, percent);
  90.             percent_complete = percent;
  91.         }
  92. #endif
  93.         if (!writelen)
  94.             break;

  96.         column = 0;
  97.         buf += bytes;
  98.         realpage++;

  100.         page = realpage & chip->pagemask;
  101.         /* Check, if we cross a chip boundary */
  102.         if (!page) {
  103.             chipnr++;
  104.             chip->select_chip(mtd, -1);
  105.             chip->select_chip(mtd, chipnr);
  106.         }
  107.     }

  109. #if 0
  110.     /* jsgood */
  111.     printf("\n");
  112. #endif
  113.     ops->retlen = ops->len - writelen;
  114.     if (unlikely(oob))
  115.         ops->oobretlen = ops->ooblen;
  116.     return ret;
  117. }
最后调用了chip->write_page
nand_scan_tail函数中有一句：

点击(此处)折叠或打开

  1. if (!chip->write_page)
  2.     {
  3.         puts("chip->write_page = nand_write_page\n");//richard
  4.         chip->write_page = nand_write_page;}



点击(此处)折叠或打开

  1. static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
  2.              const uint8_t *buf, int page, int cached, int raw)
  3. {
  4.     int status;

  6.     chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);

  8. /* jsgood: org: #else block only */
  9. #if defined(CONFIG_NAND_BL1_8BIT_ECC) && \
  10.         (defined(CONFIG_S3C6430) || \
  11.          defined(CONFIG_S3C2450) || \
  12.          defined(CONFIG_S3C2416) || \
  13.          defined(CONFIG_S5PC100) || \
  14.          defined(CONFIG_S5PC110) || \
  15.          defined(CONFIG_S5PV210) || \
  16.          defined(CONFIG_S5P6440))
  17. #ifdef CONFIG_TQ210
  18.     if ((mtd->writesize == 512 && page < 512) || (mtd->writesize == 2048 && page < 256) ||
  19.         (mtd->writesize == 4096 && page < 128)) {
  20. #else
  21.     if (page < CFG_NAND_PAGES_IN_BLOCK) {
  22. #endif
  23.         memset(chip->oob_poi, 0xff, mtd->oobsize);
  24.         s3c_nand_write_page_8bit(mtd, chip, buf);
  25.     } else
  26. #elif defined(CONFIG_NAND_BL1_8BIT_ECC) && defined(CONFIG_S3C6410)
  27.     if (page < CFG_NAND_PAGES_IN_BLOCK) {
  28.         memset(chip->oob_poi, 0xff, mtd->oobsize);
  29.         s3c_nand_write_page_8bit_for_irom(mtd, chip, buf);
  30.     } else
  31. #endif
  32.     {
  33.         if (unlikely(raw))
  34.             chip->ecc.write_page_raw(mtd, chip, buf);
  35.         else
  36.             chip->ecc.write_page(mtd, chip, buf);
  37.     }

  39.     /*
  40.      * Cached progamming disabled for now, Not sure if its worth the
  41.      * trouble. The speed gain is not very impressive. (2.3->2.6Mib/s)
  42.      */
  43.     cached = 0;

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

  47.         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
  48.         status = chip->waitfunc(mtd, chip);
  49.         /*
  50.          * See if operation failed and additional status checks are
  51.          * available
  52.          */
  53.         if ((status & NAND_STATUS_FAIL) && (chip->errstat))
  54.             status = chip->errstat(mtd, chip, FL_WRITING, status,
  55.                      page);

  57.         if (status & NAND_STATUS_FAIL)
  58.             return -EIO;
  59.     } else {
  60.         chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1);
  61.         status = chip->waitfunc(mtd, chip);
  62.     }

  64. #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
  65.     /* Send command to read back the data */
  66.     chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);

  68.     if (chip->verify_buf(mtd, buf, mtd->writesize))
  69.         return -EIO;
  70. #endif
  71.     return 0;
  72. }
这样就明白了，chip->write_page使用8bitecc，chip->ecc.write_page使用1bitecc。
mtd->write也就是调用chip->write_page使用8bitecc烧写。
另外mtd->write_oob就是执行nand_write_oob->
    if (!ops->datbuf)
        ret = nand_do_write_oob(mtd, to, ops);
    else
        ret = nand_do_write_ops(mtd, to, ops);

点击(此处)折叠或打开

  1. static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
  2.              struct mtd_oob_ops *ops)
  3. {
  4.     int chipnr, realpage, page, blockmask, column;
  5.     struct nand_chip *chip = mtd->priv;
  6.     uint32_t writelen = ops->len;
  7.     uint8_t *oob = ops->oobbuf;
  8.     uint8_t *buf = ops->datbuf;
  9.     int ret, subpage;
  10. #if 0
  11.     /* jsgood */
  12.     int percent = 0;
  13.     int percent_complete = 0;
  14. #endif
  15.     ops->retlen = 0;
  16.     if (!writelen)
  17.         return 0;

  19.     /* reject writes, which are not page aligned */
  20.     if (NOTALIGNED(to) || NOTALIGNED(ops->len)) {
  21.         printk(KERN_NOTICE "nand_write: "
  22.          "Attempt to write not page aligned data\n");
  23.         return -EINVAL;
  24.     }

  26.     column = to & (mtd->writesize - 1);
  27.     subpage = column || (writelen & (mtd->writesize - 1));

  29.     if (subpage && oob)
  30.         return -EINVAL;

  32.     chipnr = (int)(to >> chip->chip_shift);
  33.     chip->select_chip(mtd, chipnr);

  35.     /* Check, if it is write protected */
  36.     if (nand_check_wp(mtd))
  37.         return -EIO;

  39.     realpage = (int)(to >> chip->page_shift);
  40.     page = realpage & chip->pagemask;
  41.     blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;

  43.     /* Invalidate the page cache, when we write to the cached page */
  44.     if (to <= (chip->pagebuf << chip->page_shift) &&
  45.      (chip->pagebuf << chip->page_shift) < (to + ops->len))
  46.         chip->pagebuf = -1;

  48.     /* If we're not given explicit OOB data, let it be 0xFF */
  49.     if (likely(!oob))
  50.         memset(chip->oob_poi, 0xff, mtd->oobsize);

  52.     while(1) {
  53.         int bytes = mtd->writesize;
  54.         int cached = writelen > bytes && page != blockmask;
  55.         uint8_t *wbuf = buf;

  57.         /* Partial page write ? */
  58.         if (unlikely(column || writelen < (mtd->writesize - 1))) {
  59.             cached = 0;
  60.             bytes = min_t(int, bytes - column, (int) writelen);
  61.             chip->pagebuf = -1;
  62.             memset(chip->buffers->databuf, 0xff, mtd->writesize);
  63.             memcpy(&chip->buffers->databuf[column], buf, bytes);
  64.             wbuf = chip->buffers->databuf;
  65.         }

  67.         if (unlikely(oob))
  68.             oob = nand_fill_oob(chip, oob, ops);

  70.         ret = chip->write_page(mtd, chip, wbuf, page, cached,
  71.                  (ops->mode == MTD_OOB_RAW));
  72.         if (ret)
  73.             break;

  75.         writelen -= bytes;
  76. #if 0
  77.         /* jsgood */
  78.         percent = ((ops->len - writelen) * 100) / ops->len;

  80.         if (percent != percent_complete) {
  81.             printf("\rWriting page at 0x%x -- %d%% complete.", page, percent);
  82.             percent_complete = percent;
  83.         }
  84. #endif
  85.         if (!writelen)
  86.             break;

  88.         column = 0;
  89.         buf += bytes;
  90.         realpage++;

  92.         page = realpage & chip->pagemask;
  93.         /* Check, if we cross a chip boundary */
  94.         if (!page) {
  95.             chipnr++;
  96.             chip->select_chip(mtd, -1);
  97.             chip->select_chip(mtd, chipnr);
  98.         }
  99.     }

  101. #if 0
  102.     /* jsgood */
  103.     printf("\n");
  104. #endif
  105.     ops->retlen = ops->len - writelen;
  106.     if (unlikely(oob))
  107.         ops->oobretlen = ops->ooblen;
  108.     return ret;
  109. }
总结：
烧写boot、内核采用8bitecc，流程：
mtd->write > nand_write > nand_do_write_ops > chip->write_page > chip->write_page > s3c_nand_write_page_8bit(mtd, chip, buf);
烧写yaffs镜像采用1bitecc，流程：
nand_OEM_write_opts(nand, &opts,Dir) > meminfo->write_oob >
nand_write_oob->
    if (!ops->datbuf)
        ret = nand_do_write_oob(mtd, to, ops);
    else
        ret = nand_do_write_ops(mtd, to, ops);
nand_do_write_ops  >  chip->write_page  > 

chip->write_page使用8bitecc，chip->ecc.write_page使用1bitecc。
mtd->write也就是调用chip->write_page使用8bitecc烧写。

烧写函数选择：
在源数据不包含OOB的情况下使用mtd->write即nand_write函数，在源数据含有OOB（yaffs镜像）的情况下使用write_oob即nand_write_oob函数
阅读(2552) | 评论(0) | 转发(0) |
0

上一篇：AM335 u-boot mmc驱动分析

下一篇：s5pv210 uboot烧写yaffs分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6