Chinaunix首页 | 论坛 | 博客

linuxDOS的ChinaUnix博客

首页　| 　博文目录　| 　关于我

linuxDOS

  • 博客访问： 1209666
  • 博文数量： 56
  • 博客积分： 400
  • 博客等级： 一等列兵
  • 技术积分： 2800
  • 用 户 组： 普通用户
  • 注册时间： 2010-03-30 13:08
个人简介

一个人的差异在于业余时间

文章分类

全部博文（56）

文章存档

2023年（1）

2019年（1）

2018年（1）

2017年（1）

2016年（2）

2015年（20）

2014年（10）

2013年（7）

2012年（12）

2011年（1）

我的朋友
最近访客
推荐博文
相关博文
Linux NAND FLASH驱动框架分析--实例

分类： LINUX

2013-06-14 22:11:21

    在上一篇mtd框架中我们真正的东西并不多，也就是明白到底当我们看/dev/mtd0 /dev/mtdblock0 为什么会一样的效果. 理清了它们之间的关系.这里我们就nand flash驱动代码和mtd框架是如何结合的.
   话不多说了，从初始化代码我们来分析： 
  

点击(此处)折叠或打开

  1. int __init XXX_nand_init(void)
  2. {
  3.     struct nand_chip *this;
  4.     int err = 0;
  5.     int num_of_parts = 0;
  6.     const char *part_type = 0;
  7.     struct mtd_partition *mtd_parts = 0;
  8.     u32 physaddr;
  9.     int nand_dev_num;
  10.     MV_CPU_DEC_WIN addr_win;
  11.     ...

  13.     physaddr = addr_win.addrWin.baseLow;

  15.     mv_mtd = kmalloc(sizeof(struct mtd_info)+sizeof(struct nand_chip), GFP_KERNEL);
  16.     if (!mv_mtd) {
  17.         printk(KERN_INFO "Failed to allocate NAND MTD structuren");
  18.         err = -ENOMEM;
  19.         goto out;
  20.     }

  22.     memset((char *)mv_mtd, 0, sizeof(struct mtd_info) + sizeof(struct nand_chip));

  24.     baseaddr = (unsigned long)ioremap(physaddr, 1024);
  25.     if (!baseaddr) {
  26.         printk(KERN_INFO "Failed to remap NAND MTDn");
  27.         err = -EIO;
  28.         goto out_mtd;
  29.     }

  31.     this = (struct nand_chip *)((char *)mv_mtd+sizeof(struct mtd_info));
  32.     mv_mtd->priv = this;
  33.     this->IO_ADDR_R = this->IO_ADDR_W = (void __iomem *)baseaddr;
  34.     this->cmd_ctrl = board_hwcontrol;
  35. #ifdef CONFIG_MTD_NAND_LNC_8BYTE_READ
  36.     this->read_buf = mv_nand_read_buf;
  37. #endif

  39. this->ecc.mode = NAND_ECC_NONE;

  41.     this->chip_delay = 100;
  42.     if (nand_scan(mv_mtd, 1)) {
  43.         err = -ENXIO;
  44.         goto out_ior;
  45.     }

  47. #ifdef CONFIG_MTD_PARTITIONS
  48.     mv_mtd->name = "nand_mtd";
  49.     num_of_parts = parse_mtd_partitions(mv_mtd, part_probes, &mtd_parts, 0, "");
  50.     if (num_of_parts > 0)
  51.         part_type = "command line";
  52.     else
  53.         num_of_parts = 0;
  54.     if (num_of_parts == 0) {
  55.         mtd_parts = nand_parts_info;
  56.         num_of_parts = MV_NUM_OF_NAND_PARTS;
  57.         part_type = "static";
  58.     }

  60.     printk(KERN_INFO "Using %s partition definitionn", part_type);
  61.     add_mtd_partitions(mv_mtd, mtd_parts, num_of_parts);
  62. #endif
  63.     goto out;

  65. out_ior:
  66.     iounmap((void *)baseaddr);
  67. out_mtd:
  68.     kfree(mv_mtd);
  69. out:
  70.     return err;
  71. }
这里是硬件驱动的一个框架，关键部分黑体表示.
我们来看这一行： this->IO_ADDR_R = this->IO_ADDR_W = (void __iomem *)baseaddr;
这里的IO地址表示的nand flash映射的reg地址，直接操作即可操作nandflash控制器，进而操作nandflash存储芯片.
具体的时序操作控制我们这里看到：  this->cmd_ctrl = board_hwcontrol;

点击(此处)折叠或打开

  1. static void board_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
  2. {
  3.     struct nand_chip *this = (struct nand_chip *)mtd->priv;
  4.     if (ctrl & NAND_CTRL_CHANGE) {
  5.         this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W & ~3);
  6.         ctrl &= ~NAND_CTRL_CHANGE;
  7.         switch (ctrl) {
  8.         case NAND_CTRL_CLE:
  9.             this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | 1); /*x8=>1, x16=>2*/
  10.             break;
  11.         case NAND_CTRL_ALE:
  12.             this->IO_ADDR_W = (void __iomem *)((unsigned long)this->IO_ADDR_W | 2); /*x8=>2, x16=>4*/
  13.             break;
  14.         }
  15.     }
  16.     if (cmd != NAND_CMD_NONE)
  17.         writeb(cmd, this->IO_ADDR_W);
  18. }

其实就是根据nand flash时序的操作过程，来对io地址来进行不同的写值操作. 后面我们还很多函数用到它.
这里我们发现的是mv_mtd是如何初始化的呢？ 包括struct nand_chip this；我们继续往后面看nand_scan函数

点击(此处)折叠或打开

  1. /**
  2.  * nand_scan - [NAND Interface] Scan for the NAND device
  3.  * @mtd:    MTD device structure
  4.  * @maxchips:    Number of chips to scan for
  5.  *
  6.  * This fills out all the uninitialized function pointers
  7.  * with the defaults.
  8.  * The flash ID is read and the mtd/chip structures are
  9.  * filled with the appropriate values.
  10.  * The mtd->owner field must be set to the module of the caller
  11.  *
  12.  */
  13. int nand_scan(struct mtd_info *mtd, int maxchips)
  14. {
  15.     int ret;

  17.     /* Many callers got this wrong, so check for it for a while... */
  18.     if (!mtd->owner && caller_is_module()) {
  19.         printk(KERN_CRIT "%s called with NULL mtd->owner!n",
  20.                 __func__);
  21.         BUG();
  22.     }

  24.     ret = nand_scan_ident(mtd, maxchips);
  25.     if (!ret)
  26.         ret = nand_scan_tail(mtd);
  27.     return ret;
  28. }
这个函数是在nand_base.c中实现的，它包含了两个重要的函数： 

点击(此处)折叠或打开

  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 (IS_ERR(type)) {
  26.         printk(KERN_WARNING "No NAND device found!!!n");
  27.         chip->select_chip(mtd, -1);
  28.         return PTR_ERR(type);
  29.     }

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

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

  50.     return 0;
  51. }
这里我们看粗体部分的它们是在什么地方初始化的呢？ 
我们忽略了代码开始的一个函数： nand_set_defaults(chip, busw);

点击(此处)折叠或打开

  1. /*
  2.  * Set default functions
  3.  */
  4. static void nand_set_defaults(struct nand_chip *chip, int busw)
  5. {
  6.     /* check for proper chip_delay setup, set 20us if not */
  7.     if (!chip->chip_delay)
  8.         chip->chip_delay = 20;

  10.     /* check, if a user supplied command function given */
  11.     if (chip->cmdfunc == NULL)
  12.         chip->cmdfunc = nand_command;

  14.     /* check, if a user supplied wait function given */
  15.     if (chip->waitfunc == NULL)
  16.         chip->waitfunc = nand_wait;

  18.     if (!chip->select_chip)
  19.         chip->select_chip = nand_select_chip;
  20.     if (!chip->read_byte)
  21.         chip->read_byte = busw ? nand_read_byte16 : nand_read_byte;
  22.     if (!chip->read_word)
  23.         chip->read_word = nand_read_word;
  24.     if (!chip->block_bad)
  25.         chip->block_bad = nand_block_bad;
  26.     if (!chip->block_markbad)
  27.         chip->block_markbad = nand_default_block_markbad;
  28.     if (!chip->write_buf)
  29.         chip->write_buf = busw ? nand_write_buf16 : nand_write_buf;
  30.     if (!chip->read_buf)
  31.         chip->read_buf = busw ? nand_read_buf16 : nand_read_buf;
  32.     if (!chip->verify_buf)
  33.         chip->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
  34.     if (!chip->scan_bbt)
  35.         chip->scan_bbt = nand_default_bbt;

  37.     if (!chip->controller) {
  38.         chip->controller = &chip->hwcontrol;
  39.         spin_lock_init(&chip->controller->lock);
  40.         init_waitqueue_head(&chip->controller->wq);
  41.     }

  43. }
我们看到它们的默认初始化：
 chip->cmdfunc = nand_command;
 chip->select_chip = nand_select_chip;
 chip->read_byte = busw ? nand_read_byte16 : nand_read_byte;
．．．　这里我们不在一一列出．
我们明显看出它们初始化的函数都在ｍｔｄ框架里的实现的函数，似乎和真正的ｎａｎｄ　ｆｌａｓｈ驱动没有什么关系，它们是如何真正运作的呢？
我们那nand_command来做简单的分析，就会明白了.

点击(此处)折叠或打开

  1. /**
  2.  * nand_command - [DEFAULT] Send command to NAND device
  3.  * @mtd:    MTD device structure
  4.  * @command:    the command to be sent
  5.  * @column:    the column address for this command, -1 if none
  6.  * @page_addr:    the page address for this command, -1 if none
  7.  *
  8.  * Send command to NAND device. This function is used for small page
  9.  * devices (256/512 Bytes per page)
  10.  */
  11. static void nand_command(struct mtd_info *mtd, unsigned int command,
  12.              int column, int page_addr)
  13. {
  14.     register struct nand_chip *chip = mtd->priv;
  15.     int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;

  17.     /*
  18.      * Write out the command to the device.
  19.      */
  20.     if (command == NAND_CMD_SEQIN) {
  21.         int readcmd;

  23.         if (column >= mtd->writesize) {
  24.             /* OOB area */
  25.             column -= mtd->writesize;
  26.             readcmd = NAND_CMD_READOOB;
  27.         } else if (column < 256) {
  28.             /* First 256 bytes --> READ0 */
  29.             readcmd = NAND_CMD_READ0;
  30.         } else {
  31.             column -= 256;
  32.             readcmd = NAND_CMD_READ1;
  33.         }
  34.         chip->cmd_ctrl(mtd, readcmd, ctrl);
  35.         ctrl &= ~NAND_CTRL_CHANGE;
  36.     }
  37.     chip->cmd_ctrl(mtd, command, ctrl);

  39.     /*
  40.      * Address cycle, when necessary
  41.      */
  42.     ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
  43.     /* Serially input address */
  44.     if (column != -1) {
  45.         /* Adjust columns for 16 bit buswidth */
  46.         if (chip->options & NAND_BUSWIDTH_16)
  47.             column >>= 1;
  48.         chip->cmd_ctrl(mtd, column, ctrl);
  49.         ctrl &= ~NAND_CTRL_CHANGE;
  50.     }
  51.     if (page_addr != -1) {
  52.         chip->cmd_ctrl(mtd, page_addr, ctrl);
  53.         ctrl &= ~NAND_CTRL_CHANGE;
  54.         chip->cmd_ctrl(mtd, page_addr >> 8, ctrl);
  55.         /* One more address cycle for devices > 32MiB */
  56.         if (chip->chipsize > (32 << 20))
  57.             chip->cmd_ctrl(mtd, page_addr >> 16, ctrl);
  58.     }
  59.     chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);

  61.     /*
  62.      * program and erase have their own busy handlers
  63.      * status and sequential in needs no delay
  64.      */
  65.     switch (command) {

  67.     case NAND_CMD_PAGEPROG:
  68.     case NAND_CMD_ERASE1:
  69.     case NAND_CMD_ERASE2:
  70.     case NAND_CMD_SEQIN:
  71.     case NAND_CMD_STATUS:
  72.         return;

  74.     case NAND_CMD_RESET:
  75.         if (chip->dev_ready)
  76.             break;
  77.         udelay(chip->chip_delay);
  78.         chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
  79.              NAND_CTRL_CLE | NAND_CTRL_CHANGE);
  80.         chip->cmd_ctrl(mtd,
  81.              NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
  82.         while (!(chip->read_byte(mtd) & NAND_STATUS_READY)) ;
  83.         return;

  85.         /* This applies to read commands */
  86.     default:
  87.         /*
  88.          * If we don't have access to the busy pin, we apply the given
  89.          * command delay
  90.          */
  91.         if (!chip->dev_ready) {
  92.             udelay(chip->chip_delay);
  93.             return;
  94.         }
  95.     }
  96.     /* Apply this short delay always to ensure that we do wait tWB in
  97.      * any case on any machine. */
  98.     ndelay(100);

  100.     nand_wait_ready(mtd);
  101. }
看到粗体部分的函数，我们是否想起了，代码初始化的部分呢？   
 this->cmd_ctrl = board_hwcontrol; 
是的，后面的很多mtd代码里函数都会调用this->cmd_ctrl这个函数，我们就不再一一列举了.
在nand_set_defaults函数中，对struct nand_chip 结构的很多函数指针进行了初始化.
我们接着往下看这个函数：nand_get_flash_type  ，它的作用是什么呢？

点击(此处)折叠或打开

  1. /*
  2.  * Get the flash and manufacturer id and lookup if the type is supported
  3.  */
  4. static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
  5.                          struct nand_chip *chip,
  6.                          int busw, int *maf_id)
  7. {
  8.     struct nand_flash_dev *type = NULL;
  9.     int i, dev_id, maf_idx;
  10.     int tmp_id, tmp_manf;

  12.     /* Select the device */
  13.     chip->select_chip(mtd, 0);

  15.     /*
  16.      * Reset the chip, required by some chips (e.g. Micron MT29FxGxxxxx)
  17.      * after power-up
  18.      */
  19.     chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);

  21.     /* Send the command for reading device ID */
  22.     chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);

  24.     /* Read manufacturer and device IDs */
  25.     *maf_id = chip->read_byte(mtd);
  26.     dev_id = chip->read_byte(mtd);

  28.     /* Try again to make sure, as some systems the bus-hold or other
  29.      * interface concerns can cause random data which looks like a
  30.      * possibly credible NAND flash to appear. If the two results do
  31.      * not match, ignore the device completely.
  32.      */

  34.     chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);

  36.     /* Read manufacturer and device IDs */

  38.     tmp_manf = chip->read_byte(mtd);
  39.     tmp_id = chip->read_byte(mtd);

  41.     if (tmp_manf != *maf_id || tmp_id != dev_id) {
  42.         printk(KERN_INFO "%s: second ID read did not match "
  43.          "%02x,%02x against %02x,%02xn", __func__,
  44.          *maf_id, dev_id, tmp_manf, tmp_id);
  45.         return ERR_PTR(-ENODEV);
  46.     }

  48.     /* Lookup the flash id */
  49.     for (i = 0; nand_flash_ids[i].name != NULL; i++) {
  50.         if (dev_id == nand_flash_ids[i].id) {
  51.             type = &nand_flash_ids[i];
  52.             break;
  53.         }
  54.     }

  56.     if (!type)
  57.         return ERR_PTR(-ENODEV);

  59.     if (!mtd->name) {
  60. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  61.         sprintf(nand_name, "%s%s", type->name,
  62.                 (chip->num_devs == 2) ? " - Ganged" : "");
  63.         type->name = nand_name;
  64. #endif
  65.         mtd->name = type->name;
  66.     }

  68.     chip->chipsize = (uint64_t)type->chipsize << 20;
  69. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  70.     chip->chipsize *= chip->num_devs;
  71.     if(chip->num_devs > 1)
  72.         type->options |= NAND_BUSWIDTH_16;
  73. #endif

  75.     /* Newer devices have all the information in additional id bytes */
  76.     if (!type->pagesize) {
  77.         int extid;
  78.         /* The 3rd id byte holds MLC / multichip data */
  79.         chip->cellinfo = chip->read_byte(mtd);
  80.         /* The 4th id byte is the important one */
  81.         extid = chip->read_byte(mtd);
  82.         /* Calc pagesize */
  83.         mtd->writesize = 1024 << (extid & 0x3);
  84.         extid >>= 2;
  85.         /* Calc oobsize */
  86.         mtd->oobsize = (8 << (extid & 0x01)) * (mtd->writesize >> 9);
  87. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  88.                         mtd->writesize *= chip->num_devs;
  89. #endif
  90.         extid >>= 2;
  91.         /* Calc blocksize. Blocksize is multiples of 64KiB */
  92.         mtd->erasesize = (64 * 1024) << (extid & 0x03);
  93. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  94.                         mtd->erasesize *= chip->num_devs;
  95. #endif
  96.         extid >>= 2;
  97.         /* Get buswidth information */
  98.         busw = (extid & 0x01) ? NAND_BUSWIDTH_16 : 0;
  99. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  100.                         if(chip->num_devs > 1)
  101.                                 busw = NAND_BUSWIDTH_16;
  102. #endif
  103.     } else {
  104.         /*
  105.          * Old devices have chip data hardcoded in the device id table
  106.          */
  107.         mtd->erasesize = type->erasesize;
  108.         mtd->writesize = type->pagesize;
  109.         mtd->oobsize = mtd->writesize / 32;
  110. #ifdef CONFIG_MTD_NAND_NFC_MLC_SUPPORT
  111.         /* New devices have non standard OOB size */
  112.         if (chip->oobsize_ovrd)
  113.             mtd->oobsize = chip->oobsize_ovrd;
  114. #endif
  115.         busw = type->options & NAND_BUSWIDTH_16;
  116. #ifdef CONFIG_MTD_NAND_NFC_GANG_SUPPORT
  117.         mtd->erasesize *= chip->num_devs;
  118.         mtd->writesize *= chip->num_devs;
  119. #endif
  120.     }

  122.     /* Try to identify manufacturer */
  123.     for (maf_idx = 0; nand_manuf_ids[maf_idx].id != 0x0; maf_idx++) {
  124.         if (nand_manuf_ids[maf_idx].id == *maf_id)
  125.             break;
  126.     }

  128.     /*
  129.      * Check, if buswidth is correct. Hardware drivers should set
  130.      * chip correct !
  131.      */
  132.     if (busw != (chip->options & NAND_BUSWIDTH_16)) {
  133.         printk(KERN_INFO "NAND device: Manufacturer ID:"
  134.          " 0x%02x, Chip ID: 0x%02x (%s %s)n", *maf_id,
  135.          dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
  136.         printk(KERN_WARNING "NAND bus width %d instead %d bitn",
  137.          (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,
  138.          busw ? 16 : 8);
  139.         return ERR_PTR(-EINVAL);
  140.     }

  142.     /* Calculate the address shift from the page size */
  143.     chip->page_shift = ffs(mtd->writesize) - 1;
  144.     /* Convert chipsize to number of pages per chip -1. */
  145.     chip->pagemask = (chip->chipsize >> chip->page_shift) - 1;

  147.     chip->bbt_erase_shift = chip->phys_erase_shift =
  148.         ffs(mtd->erasesize) - 1;
  149.     if (chip->chipsize & 0xffffffff)
  150.         chip->chip_shift = ffs((unsigned)chip->chipsize) - 1;
  151.     else
  152.         chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32)) + 32 - 1;

  154.     /* Set the bad block position */
  155.     chip->badblockpos = mtd->writesize > 512 ?
  156.         NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;

  158.     /* Get chip options, preserve non chip based options */
  159.     chip->options &= ~NAND_CHIPOPTIONS_MSK;
  160.     chip->options |= type->options & NAND_CHIPOPTIONS_MSK;

  162.     /*
  163.      * Set chip as a default. Board drivers can override it, if necessary
  164.      */
  165.     chip->options |= NAND_NO_AUTOINCR;

  167.     /* Check if chip is a not a samsung device. Do not clear the
  168.      * options for chips which are not having an extended id.
  169.      */
  170.     if (*maf_id != NAND_MFR_SAMSUNG && !type->pagesize)
  171.         chip->options &= ~NAND_SAMSUNG_LP_OPTIONS;

  173.     /* Check for AND chips with 4 page planes */
  174.     if (chip->options & NAND_4PAGE_ARRAY)
  175.         chip->erase_cmd = multi_erase_cmd;
  176.     else
  177.         chip->erase_cmd = single_erase_cmd;

  179.     /* Do not replace user supplied command function ! */
  180.     if (mtd->writesize > 512 && chip->cmdfunc == nand_command)
  181.         chip->cmdfunc = nand_command_lp;

  183.     printk(KERN_INFO "NAND device: Manufacturer ID:"
  184.      " 0x%02x, Chip ID: 0x%02x (%s %s)n", *maf_id, dev_id,
  185.      nand_manuf_ids[maf_idx].name, type->name);

  187.     return type;
  188. }

从注释中我们已经很清晰了，但是这里不能忽略的是粗体部分，尤其是nand_flash_ids，在初始化的时候我们要把我们特定ｎａｎｄ　ｆｌａｓｈ信息添加到这个表里。才能识别，不然驱动就没法往下继续执行了．
我们继续回到nand_scan函数中来，我们看另外一个关键的函数：

点击(此处)折叠或打开

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

  14.     if (!(chip->options & NAND_OWN_BUFFERS))
  15.         chip->buffers = kmalloc(sizeof(*chip->buffers), GFP_KERNEL);
  16.     if (!chip->buffers)
  17.         return -ENOMEM;

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

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

  46.     if (!chip->write_page)
  47.         chip->write_page = nand_write_page;

  49.     /*
  50.      * check ECC mode, default to software if 3byte/512byte hardware ECC is
  51.      * selected and we have 256 byte pagesize fallback to software ECC
  52.      */

  54.     switch (chip->ecc.mode) {
  55.     case NAND_ECC_HW_OOB_FIRST:
  56.         /* Similar to NAND_ECC_HW, but a separate read_page handle */
  57.         if (!chip->ecc.calculate || !chip->ecc.correct ||
  58.          !chip->ecc.hwctl) {
  59.             printk(KERN_WARNING "No ECC functions supplied; "
  60.              "Hardware ECC not possiblen");
  61.             BUG();
  62.         }
  63.         if (!chip->ecc.read_page)
  64.             chip->ecc.read_page = nand_read_page_hwecc_oob_first;

  66.     case NAND_ECC_HW:
  67.         /* Use standard hwecc read page function ? */
  68.         if (!chip->ecc.read_page)
  69.             chip->ecc.read_page = nand_read_page_hwecc;
  70.         if (!chip->ecc.write_page)
  71.             chip->ecc.write_page = nand_write_page_hwecc;
  72.         if (!chip->ecc.read_page_raw)
  73.             chip->ecc.read_page_raw = nand_read_page_raw;
  74.         if (!chip->ecc.write_page_raw)
  75.             chip->ecc.write_page_raw = nand_write_page_raw;
  76.         if (!chip->ecc.read_oob)
  77.             chip->ecc.read_oob = nand_read_oob_std;
  78.         if (!chip->ecc.write_oob)
  79.             chip->ecc.write_oob = nand_write_oob_std;

  81.     case NAND_ECC_HW_SYNDROME:
  82.         if ((!chip->ecc.calculate || !chip->ecc.correct ||
  83.          !chip->ecc.hwctl) &&
  84.          (!chip->ecc.read_page ||
  85.          chip->ecc.read_page == nand_read_page_hwecc ||
  86.          !chip->ecc.write_page ||
  87.          chip->ecc.write_page == nand_write_page_hwecc)) {
  88.             printk(KERN_WARNING "No ECC functions supplied; "
  89.              "Hardware ECC not possiblen");
  90.             BUG();
  91.         }
  92.         /* Use standard syndrome read/write page function ? */
  93.         if (!chip->ecc.read_page)
  94.             chip->ecc.read_page = nand_read_page_syndrome;
  95.         if (!chip->ecc.write_page)
  96.             chip->ecc.write_page = nand_write_page_syndrome;
  97.         if (!chip->ecc.read_page_raw)
  98.             chip->ecc.read_page_raw = nand_read_page_raw_syndrome;
  99.         if (!chip->ecc.write_page_raw)
  100.             chip->ecc.write_page_raw = nand_write_page_raw_syndrome;
  101.         if (!chip->ecc.read_oob)
  102.             chip->ecc.read_oob = nand_read_oob_syndrome;
  103.         if (!chip->ecc.write_oob)
  104.             chip->ecc.write_oob = nand_write_oob_syndrome;

  106.         if (mtd->writesize >= chip->ecc.size)
  107.             break;
  108.         printk(KERN_WARNING "%d byte HW ECC not possible on "
  109.          "%d byte page size, fallback to SW ECCn",
  110.          chip->ecc.size, mtd->writesize);
  111.         chip->ecc.mode = NAND_ECC_SOFT;

  113.     case NAND_ECC_SOFT:
  114.         chip->ecc.calculate = nand_calculate_ecc;
  115.         chip->ecc.correct = nand_correct_data;
  116.         chip->ecc.read_page = nand_read_page_swecc;
  117.         chip->ecc.read_subpage = nand_read_subpage;
  118.         chip->ecc.write_page = nand_write_page_swecc;
  119.         chip->ecc.read_page_raw = nand_read_page_raw;
  120.         chip->ecc.write_page_raw = nand_write_page_raw;
  121.         chip->ecc.read_oob = nand_read_oob_std;
  122.         chip->ecc.write_oob = nand_write_oob_std;
  123.         if (!chip->ecc.size)
  124.             chip->ecc.size = 256;
  125.         chip->ecc.bytes = 3;
  126.         break;

  128.     case NAND_ECC_NONE:
  129.         printk(KERN_WARNING "NAND_ECC_NONE selected by board driver. "
  130.          "This is not recommended !!n");
  131.         #if 0
  132.                 /*close internal ecc */
  133.          nand_command(mtd, 0xEF, 0x90, -1);
  134.          writeb(0x00, chip->IO_ADDR_W);
  135.          writeb(0x00, chip->IO_ADDR_W);
  136.          writeb(0x00, chip->IO_ADDR_W);    
  137.          writeb(0x00, chip->IO_ADDR_W);
  138.          printk("close internal ecc ");
  139.          #endif
  140.         chip->ecc.read_page = nand_read_page_raw;
  141.         chip->ecc.write_page = nand_write_page_raw;
  142.         chip->ecc.read_oob = nand_read_oob_std;
  143.         chip->ecc.read_page_raw = nand_read_page_raw;
  144.         chip->ecc.write_page_raw = nand_write_page_raw;
  145.         chip->ecc.write_oob = nand_write_oob_std;
  146.         chip->ecc.size = 512;//mtd->writesize;
  147.         chip->ecc.bytes = 8;//0;
  148.         break;

  150.     default:
  151.         printk(KERN_WARNING "Invalid NAND_ECC_MODE %dn",
  152.          chip->ecc.mode);
  153.         BUG();
  154.     }

  156.     /*
  157.      * The number of bytes available for a client to place data into
  158.      * the out of band area
  159.      */
  160.     chip->ecc.layout->oobavail = 0;
  161.     for (i = 0; chip->ecc.layout->oobfree[i].length
  162.             && i < ARRAY_SIZE(chip->ecc.layout->oobfree); i++)
  163.         chip->ecc.layout->oobavail +=
  164.             chip->ecc.layout->oobfree[i].length;
  165.     mtd->oobavail = chip->ecc.layout->oobavail;

  167.     /*
  168.      * Set the number of read / write steps for one page depending on ECC
  169.      * mode
  170.      */
  171.     chip->ecc.steps = mtd->writesize / chip->ecc.size;
  172.     if(chip->ecc.steps * chip->ecc.size != mtd->writesize) {
  173.         printk(KERN_WARNING "Invalid ecc parametersn");
  174.         BUG();
  175.     }
  176.     chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;

  178.     /*
  179.      * Allow subpage writes up to ecc.steps. Not possible for MLC
  180.      * FLASH.
  181.      */
  182.     if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&
  183.      !(chip->cellinfo & NAND_CI_CELLTYPE_MSK)) {
  184.         switch(chip->ecc.steps) {
  185.         case 2:
  186.             mtd->subpage_sft = 1;
  187.             break;
  188.         case 4:
  189.         case 8:
  190.         case 16:
  191.             mtd->subpage_sft = 2;
  192.             break;
  193.         }
  194.     }
  195.     chip->subpagesize = mtd->writesize >> mtd->subpage_sft;

  197.     /* Initialize state */
  198.     chip->state = FL_READY;

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

  203.     /* Invalidate the pagebuffer reference */
  204.     chip->pagebuf = -1;

  206.     /* Fill in remaining MTD driver data */
  207.     mtd->type = MTD_NANDFLASH;
  208.     mtd->flags = MTD_CAP_NANDFLASH;
  209.     mtd->erase = nand_erase;
  210.     mtd->point = NULL;
  211.     mtd->unpoint = NULL;
  212.     mtd->read = nand_read;
  213.     mtd->write = nand_write;
  214.     mtd->read_oob = nand_read_oob;
  215.     mtd->write_oob = nand_write_oob;
  216.     mtd->sync = nand_sync;
  217.     mtd->lock = NULL;
  218.     mtd->unlock = NULL;
  219.     mtd->suspend = nand_suspend;
  220.     mtd->resume = nand_resume;
  221.     mtd->block_isbad = nand_block_isbad;
  222.     mtd->block_markbad = nand_block_markbad;

  224.     /* propagate ecc.layout to mtd_info */
  225.     mtd->ecclayout = chip->ecc.layout;

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

  231.     /* Build bad block table */
  232.     return chip->scan_bbt(mtd);
  233. }
这里加入关于ecc校验函数的一些初始化.对于nand flash的ecc对数据位的ecc校验的重要性和必要性，这么我们不多解释.当然关于nandflash芯片的具体oob信息需要在这里初始化和指定，不然读不到正确的数据(还有一些nand flash芯片支持内置校验，关于校验我们足够在写一篇了), 最后就是对mtd的一些操作函数的初始化.
这里我们还是在简单的说明下这个函数的一些部分： 

点击(此处)折叠或打开

  1. /**
  2.  * nand_read_page_raw - [Intern] read raw page data without ecc
  3.  * @mtd:    mtd info structure
  4.  * @chip:    nand chip info structure
  5.  * @buf:    buffer to store read data
  6.  * @page:    page number to read
  7.  *
  8.  * Not for syndrome calculating ecc controllers, which use a special oob layout
  9.  */
  10. static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
  11.              uint8_t *buf, int page)
  12. {
  13.     chip->read_buf(mtd, buf, mtd->writesize);
  14.     chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
  15.     return 0;
  16. }

看到没有chip->read_buf其实都是通过chip->cmd_ctrl的各种封装和操作.最后就是对mtd的初始化，这里我们终于看到了.
我们看一下：  mtd->read =nand_read;

点击(此处)折叠或打开

  1. /**
  2.  * nand_read - [MTD Interface] MTD compability function for nand_do_read_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.  *
  9.  * Get hold of the chip and call nand_do_read
  10.  */
  11. static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
  12.          size_t *retlen, uint8_t *buf)
  13. {
  14.     struct nand_chip *chip = mtd->priv;
  15.     int ret;

  17.     /* Do not allow reads past end of device */
  18.     if ((from + len) > mtd->size)
  19.         return -EINVAL;
  20.     if (!len)
  21.         return 0;

  23.     nand_get_device(chip, mtd, FL_READING);

  25.     chip->ops.len = len;
  26.     chip->ops.datbuf = buf;
  27.     chip->ops.oobbuf = NULL;

  29.     ret = nand_do_read_ops(mtd, from, &chip->ops);

  31.     *retlen = chip->ops.retlen;

  33.     nand_release_device(mtd);

  35.     return ret;
  36. }
 nand_do_read_ops(mtd, from, &chip->ops);关键的一行代码，它也是通过chip里一些函数来实现真正的操作.
关于文章开始代码的初始化函数的最后一个操作就是add_mtd_partitions了.网上很多文章对这个函数都解释的很好的.
这里为什么这么长篇大论的自己分析一番，当然只是一个小小的入门和开始.这里都是针对linux kernel里的代码来说明，有机会也要说下uboot下是如何初始化的.











阅读(10139) | 评论(0) | 转发(3) |
0

上一篇：Linux NAND FLASH驱动框架分析---mtd

下一篇：网络中MTU与MSS

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

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

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

16024965号-6