mtd nandflash 分析

一、MTD 的概念和层次

MTD(memory technology device 存储 技术设备 ) 是用于访问 memory 设备（ ROM 、 flash ）的 Linux 的子系统。 MTD 的主要目的是为了使新的 memory 设备的驱动更加简单，为此它在硬件和上层之间提供了一个抽象的接口。 MTD 的所有源代码在 /drivers/mtd 子目录下 。[1]

传统上， UNIX 只认识块设备和字符设备。字符设备是类似键盘或者鼠标的这类设备，你必须从它读取当前数据，但是不可以定位也没有大小。块设备有固定的大小并且可以定位， 它们恰好组织成许多字节的块，通常为 512字节。

闪存既不满足块设备描述也不满足字符设备的描述。它们表现的类似块设备，但又有所不同。比如，块设备不区分写和擦除操作。因此，一种符合闪存特性的特殊设备类型诞生了， 就是 MTD 设备。所以 MTD 既不是块设备，也不是字符设备 。 [2]

关于 MTD 的层次，网络上有一张流传盛广的图片，如下所示，但是最初我看了这幅图根本是一点概念都没有的，不过通过看代码和网上查阅资料，知道了详细一点的分层结构，也纠正了一些前期对这张图的误解。

( 以下这部分纯属个人理解，如果有误，请高人拍砖 !)

为了方便理解，先声明两点：

1. xxx 层 (MTD 原始设备层， MTD 块设备层 ) ，实现封装的代码。

2. xxx 设备 (MTD 原始设备， MTD 块设备 ) ，是 xxx 层向下封装后呈现给上层的表象就 是一个 xxx 设备。

Flash 硬件驱动层：该层的基于特定处理器和特定 flash 芯片，这里以 pxa935 和Hynix  NAND 512MB 1.8V 16-bit 为例。使用类型为 nand_chip,   pxa3xx_nand_info, dfc_context, pxa3xx_bbm 这几个结构体来实现硬 件驱动。代码位于 drivers/mtd/nand 目录下。

MTD 原始设备层： 用类型 mtd_info 的结构体来描述 MTD 原始设备，该结构体中有一 个域会指向 Flash 硬件驱动层中所有使用的结构体 ( 串联形式，另外  pxa3xx_bbm 结构体是只在底层驱动中使用 ) 。

  NAND flash 在嵌入式系统中通常需要划分多个分区，系统没有运 行起来的时候分区表现为 mtd_partition 类型的结构体数组，该数组由 工程师自己决定。在系统初始化，确切的说是在nand 的驱动加载时 执行相应的 prob 函数时，会将上述数组中的每一个分区用类型为 mtd_part的结构体来描述。因为 mtd_part 结构体中内嵌了一个 mtd_info 的结构体，所以每一个分区在系统看来都是一个 MTD 原始 设备，另外 mtd_part 种还有一个 master 指针，指向描述整片 flash原 始设备的 mtd_info 结构体，所以这个描述整片 nand 的 mtd_info 结构 体也被叫做主分区。

  在 MTD 原始设备层和其上层 MTD 块设备层 (FTL) 活跃着一个牛 X 的指针数组 mtd_table，定义于文件 mtdcore.c 中，该数组就是所有 MTD 原始设备的指针列表 ( 当然有数量限制，这里限制在 32 范围内 ) 。 不过上面所说的主分区没有在 mtd_table 之列。

       如果你系统中有 2 片 nand flash ，每个有 8 个分区，那么系统中总 共存在有 18 个 mtd_info 结构体对象， mtd_table 数组中有 16 个指针 已经有归属。

本层和其上层 FTL 之间就全靠 mtd_table 数组和 mtd_notifiers 链表来         

联系了 ，至于如何联系的，下文再详细解释。

MTD 块设备层： 该层也叫flash 翻译层 (FTL) 。以前为了在 MTD 设备上使用某种传统 的文件系统， linux 系统中存在一个叫做 flash 翻译层 (FTL) ，该 FTL 是在 MTD 原始设备的基础上模拟出块设备，所以 FTL 以下的所有内 容呈现给上层的就是一个块设备。这样可以使用通用的块设备的接口 了。

这里也存在一个著名的结构体指针数组，定义于 mtdblock.c 文件中， 其中的每一个指针均指向一个 struct mtdblk_dev 的类型的对象，每一 个 struct mtdblk_dev 类型的对象都是一个MTD 块设备。

网上流传着说使用该 FTL 如何不好，这种观点其实是基于使用传统 文件系统存在的问题，现在有专门针对 nand flash 的 yaffs 日志型文 件系统了。所以那种掉电丢失数据的风险降低到了很小很小。

通用磁盘层：    再上层就是通用磁盘层了，其实每个分区在最后都是向通用磁盘层注 册成了一个 disk 来使用的，后面分析代码会看到这部分。当然对于 block 层的分析不在本文之中讨论。

本来最初的目的只是为了研究内核中nand的驱动，但好奇心太强，忍不住往上层追溯，然后再往下层跟踪。这个过程中，
 特别是在block层，yaffs文件系统和用户空间中相关的分析，其实仅仅只是找到了他们之间的关键联系点而已，没有深
 入详细分析。
 
 * linux2.6.29
 * pxa935
 * Hynix NAND 512MB 1.8V 16-bit
 * 李枝果/lizgo 2010-11-8 [e-mail]
 * 由于本人水平有限，望读者阅读时三思，同时也指正我的错误，谢谢！
 
 话说MTD子系统向上层提供了几种在用户空间可以直接使用的接口：Raw char device、Raw block device、FTL、NFTL、
 JFFS(2)。前文中主要讨论的yaffs文件系统没有包含在其中，因为yaffs是直接建立在MTD原始设备层之上的。在nand驱动
 注册的时候，会在probe函数中将nand的每个分区通过mtd块设备层、通用磁盘层、block层向内核注册成一个block设备。
 另外挂载yaffs文件系统的时候呢，就会通过设备节点找到block层中对应的block_device结构体，最后在填充超级块的时候
 直接通过主次设备号在mtd_table[]中找到对应的mtd_info结构体。而且在yaffs文件系统层封装的读写等函数中，也是将
 找到的mtd_info结构体传入，直接利用了mtd_info结构体中的相关读写函数指针来进行底层的读写。
 
 本文主要讨论的接口是Raw block device，也就是传说中的mtdblock，本文中称为mtdblock翻译层，
 主要集中在文件drivers/mtd/mtdblock.c
一、init_mtdblock()
static struct mtd_blktrans_ops mtdblock_tr = {
 .name  = "mtdblock",
 .major  = 31,
 .part_bits = 0,
 .blksize  = 512,
 .open  = mtdblock_open,
 .flush  = mtdblock_flush,
 .release = mtdblock_release,
 .readsect = mtdblock_readsect,
 .writesect = mtdblock_writesect,
 .add_mtd = mtdblock_add_mtd,
 .remove_dev = mtdblock_remove_dev,
 .owner  = THIS_MODULE,
};
static int __init init_mtdblock(void)
{
 return register_mtd_blktrans(&mtdblock_tr);
}
int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
 int ret, i;
 /* Register the notifier if/when the first device type is
    registered, to prevent the link/init ordering from fucking
    us over. */ 
 // 注册一个该接口的用户通知器，在分区动态添加或删除的时候被调用，
 // 通知使用该接口的用户做出相应动作。
 // 关于这个用户通知器后面再介绍
 if (!blktrans_notifier.list.next)
  register_mtd_user(&blktrans_notifier);
 tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
 if (!tr->blkcore_priv)
  return -ENOMEM;
 mutex_lock(&mtd_table_mutex);
 ret = register_blkdev(tr->major, tr->name); // 块设备注册,major_names
 // 此时可以在proc/devices中看到注册的该设备
 if (ret) {
  printk(KERN_WARNING "Unable to register %s block device on major %d: %d/n",
         tr->name, tr->major, ret);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return ret;
 }
 spin_lock_init(&tr->blkcore_priv->queue_lock);  // 初始化请求队列锁
 tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
 // 初始化请求队列头和安装请求处理函数mtd_blktrans_request()
 if (!tr->blkcore_priv->rq) {
  unregister_blkdev(tr->major, tr->name);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return -ENOMEM;
 }
 tr->blkcore_priv->rq->queuedata = tr; // 保存该翻译层的操作集  ， &mtdblock_tr
 blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
 if (tr->discard)
  blk_queue_set_discard(tr->blkcore_priv->rq,
          blktrans_discard_request);
 tr->blkshift = ffs(tr->blksize) - 1;
 tr->blkcore_priv->thread = kthread_run(mtd_blktrans_thread, tr,
   "%sd", tr->name);      // 创建内核线程mtd_blktrans_thread
 if (IS_ERR(tr->blkcore_priv->thread)) {
  blk_cleanup_queue(tr->blkcore_priv->rq);
  unregister_blkdev(tr->major, tr->name);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return PTR_ERR(tr->blkcore_priv->thread);
 }
 INIT_LIST_HEAD(&tr->devs);// 该链表用来挂接使用该翻译层的所有设备
 list_add(&tr->list, &blktrans_majors);
 // 所有翻译层通过blktrans_majors链表来链接在一起
 for (i=0; i<MAX_MTD_DEVICES; i++) {
  if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
   tr->add_mtd(tr, mtd_table[i]);
 }
 // 对mtd_table中的所有分区调用该翻译层操作集中的add_mtd函数
 mutex_unlock(&mtd_table_mutex);
 return 0;
}
 使用函数blk_init_queue初始化一个请求队列和安装一个请求处理函数mtd_blktrans_request():
static void mtd_blktrans_request(struct request_queue *rq)
 {
  struct mtd_blktrans_ops *tr = rq->queuedata;
  wake_up_process(tr->blkcore_priv->thread);  // 唤醒内核线程
 }
 接下来就创建一个内核线程：mtd_blktrans_thread()
static int mtd_blktrans_thread(void *arg)
{
 struct mtd_blktrans_ops *tr = arg;
 struct request_queue *rq = tr->blkcore_priv->rq;
 /* we might get involved when memory gets low, so use PF_MEMALLOC */
 current->flags |= PF_MEMALLOC;
 spin_lock_irq(rq->queue_lock);
 while (!kthread_should_stop()) {
  struct request *req;
  struct mtd_blktrans_dev *dev;
  int res = 0;
  req = elv_next_request(rq);  // 获取对列中第一个未完成的请求
  if (!req) {      // 如果请求为空将线程置于睡眠状态
   set_current_state(TASK_INTERRUPTIBLE);
   spin_unlock_irq(rq->queue_lock);
   schedule();
   spin_lock_irq(rq->queue_lock);
   continue;
  }
  
  /*
  一个请求队列管理着很多请求，但是每一个请求都只能针对一个块设备gendisk。
  所以每一个请求被创建出来后都会指向它的请求对象gendisk。
  这个指向关系在函数__make_request()->init_request_from_bio()->blk_rq_bio_prep()
  -> rq->rq_disk = bio->bi_bdev->bd_disk
  中建立。
  */ 
  
  dev = req->rq_disk->private_data;
  tr = dev->tr;
  spin_unlock_irq(rq->queue_lock);
  mutex_lock(&dev->lock);
  res = do_blktrans_request(tr, dev, req);
  /*
  在函数do_blktrans_request(tr, dev, req)中
  根据请求的数据传输方向来决定调用读或写函数进行数据传输
  tr->readsect(dev, block, buf)
  tr->writesect(dev, block, buf)
  */
  //如果res是0表示不能成功完成请求，为非0表示成功完成请求
  mutex_unlock(&dev->lock);
  spin_lock_irq(rq->queue_lock);
  end_request(req, res);
 }
 spin_unlock_irq(rq->queue_lock);
 return 0;
}
 
二、用户通知器
结构体定义：
struct mtd_notifier {
 void (*add)(struct mtd_info *mtd);
 void (*remove)(struct mtd_info *mtd);
 struct list_head list;
};
有两个方法和一个链表挂钩，参数均为mtd_info指针。
在drivers/mtd/mtd_blkdevs.c中定义了下面的块翻译层通知器
static struct mtd_notifier blktrans_notifier = {
 .add = blktrans_notify_add,
 .remove = blktrans_notify_remove,
};
该通知器被FTL、NFTL、mtdblock翻译层使用。
int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
...
/* Register the notifier if/when the first device type is
  registered, to prevent the link/init ordering from fucking
  us over. */ 
if (!blktrans_notifier.list.next)
  register_mtd_user(&blktrans_notifier); // 只有第一个翻译层注册的时候该函数才会调用
...
}
void register_mtd_user (struct mtd_notifier *new)
{
 int i;
 mutex_lock(&mtd_table_mutex);
 list_add(&new->list, &mtd_notifiers);
 // 将这个新的用户通知器添加到全局链表mtd_notifiers中(该链表中还可能存在其他用户通知器)
  __module_get(THIS_MODULE);// 增加模块引用计数
 for (i=0; i< MAX_MTD_DEVICES; i++)
  if (mtd_table[i])
   new->add(mtd_table[i]);
   // 对mtd_table中的所有分区调用该翻译层操作集中的add_mtd函数，第一次注册该工作在后面会重复再做一次
   // blktrans_notify_add()
 mutex_unlock(&mtd_table_mutex);
}
static void blktrans_notify_add(struct mtd_info *mtd)
{
 struct mtd_blktrans_ops *tr;
 if (mtd->type == MTD_ABSENT)
  return;
 list_for_each_entry(tr, &blktrans_majors, list)
  tr->add_mtd(tr, mtd);
  // blktrans_majors链表管理着所有的翻译层操作集结构体
  // 该处的意思是对于传入的同一个mtd_info结构体，所有的翻译层都会调用自己的
  // add_mtd函数(这些函数都不一样，对于mtdblock层该函数是mtdblock_add_mtd())
}
在系统启动的时候，register_mtd_blktrans(&mtdblock_tr)执行的时候，mtd_table数组中是空的，所以就不会执行到翻译层
的add_mtd函数上来，那么在又在什么时候调用了翻译层的add_mtd()函数了呢？请看下面
三、将分区向上层注册成block device。
 // pxa3xx_nand.c
 在注册nand驱动的时候：
 pxa3xx_nand_init()
 --> platform_driver_register()
   --> ...经过注册和设备匹配后调用probe()函数
     --> pxa3xx_nand_probe()
       --> ...
       --> add_mtd_partitions(monahans_mtd, pdata->parts, pdata->nr_parts)
         --> add_one_partition()
           --> add_mtd_device()
             --> list_for_each_entry(not, &mtd_notifiers, list)
                 not->add(mtd);
               // 这里就是调用mtd_notifiers链表中所有用户通知器的add函数，以mtdblock的用户通知
               // 器为例，那么就是调用函数 mtdblock_add_mtd()。这就是证实了当添加一个分区的时候
               // 用户通知器的add函数被调用，那么当移除分区的时候，remove函数就会被调用，只是
               // 我们这里没有移除的分区动作。
代码如下：
static int pxa3xx_nand_probe(struct platform_device *pdev)
{
 ...
 return add_mtd_partitions(monahans_mtd, pdata->parts, pdata->nr_parts);
 ...
}
int add_mtd_partitions(struct mtd_info *master,
         const struct mtd_partition *parts,
         int nbparts)
{
 struct mtd_part *slave;
 uint64_t cur_offset = 0;
 int i;
 printk(KERN_NOTICE "Creating %d MTD partitions on /"%s/":/n", nbparts, master->name);
 for (i = 0; i < nbparts; i++) {
  slave = add_one_partition(master, parts + i, i, cur_offset);
  if (!slave)
   return -ENOMEM;
  cur_offset = slave->offset + slave->mtd.size;
 }
 return 0;
}
static struct mtd_part *add_one_partition(struct mtd_info *master,
  const struct mtd_partition *part, int partno,
  uint64_t cur_offset)
{
 struct mtd_part *slave;
 /* allocate the partition structure */
 slave = kzalloc(sizeof(*slave), GFP_KERNEL);
 if (!slave) {
  printk(KERN_ERR"memory allocation error while creating partitions for /"%s/"/n",
   master->name);
  del_mtd_partitions(master);
  return NULL;
 }
 list_add(&slave->list, &mtd_partitions);
 // mtd_partitions 用于在MTD原始设备层统一管理所有分区信息
 // static LIST_HEAD(mtd_partitions) 本文件中定义
 /* set up the MTD object for this partition */
 slave->mtd.type = master->type;
 slave->mtd.flags = master->flags & ~part->mask_flags;
 slave->mtd.size = part->size;  // 分区大小
 slave->mtd.writesize = master->writesize;
 slave->mtd.oobsize = master->oobsize;
 slave->mtd.oobavail = master->oobavail;
 slave->mtd.subpage_sft = master->subpage_sft;
 slave->mtd.name = part->name;  // 分区名字
 slave->mtd.owner = master->owner;
 slave->mtd.read = part_read;  // 分区读写函数
 slave->mtd.write = part_write;
 if (master->panic_write)
  slave->mtd.panic_write = part_panic_write;
 if (master->point && master->unpoint) {
  slave->mtd.point = part_point;
  slave->mtd.unpoint = part_unpoint;
 }
 if (master->read_oob)
  slave->mtd.read_oob = part_read_oob;
 if (master->write_oob)
  slave->mtd.write_oob = part_write_oob;
 if (master->read_user_prot_reg)
  slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
 if (master->read_fact_prot_reg)
  slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
 if (master->write_user_prot_reg)
  slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
 if (master->lock_user_prot_reg)
  slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
 if (master->get_user_prot_info)
  slave->mtd.get_user_prot_info = part_get_user_prot_info;
 if (master->get_fact_prot_info)
  slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
 if (master->sync)
  slave->mtd.sync = part_sync;
 if (!partno && master->suspend && master->resume) {
   slave->mtd.suspend = part_suspend;
   slave->mtd.resume = part_resume;
 }
 if (master->writev)
  slave->mtd.writev = part_writev;
 if (master->lock)
  slave->mtd.lock = part_lock;
 if (master->unlock)
  slave->mtd.unlock = part_unlock;
 if (master->block_isbad)
  slave->mtd.block_isbad = part_block_isbad;
 if (master->block_markbad)
  slave->mtd.block_markbad = part_block_markbad;
 slave->mtd.erase = part_erase;
 slave->master = master;   // 该分区的主分区
 slave->offset = part->offset; // 该分区偏移
 slave->index = partno;   // 分区索引
 if (slave->offset == MTDPART_OFS_APPEND)
  slave->offset = cur_offset;
 if (slave->offset == MTDPART_OFS_NXTBLK) {
  slave->offset = cur_offset;
  if (mtd_mod_by_eb(cur_offset, master) != 0) {
   /* Round up to next erasesize */
   slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
   printk(KERN_NOTICE "Moving partition %d: "
          "0x%012llx -> 0x%012llx/n", partno,
          (unsigned long long)cur_offset, (unsigned long long)slave->offset);
  }
 }
 if (slave->mtd.size == MTDPART_SIZ_FULL)
  slave->mtd.size = master->size - slave->offset;
 printk(KERN_NOTICE "0x%012llx-0x%012llx : /"%s/"/n", (unsigned long long)slave->offset,
  (unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name);
 // 打印分区表信息
 /* let's do some sanity checks */
 if (slave->offset >= master->size) {
  /* let's register it anyway to preserve ordering */
  slave->offset = 0;
  slave->mtd.size = 0;
  printk(KERN_ERR"mtd: partition /"%s/" is out of reach -- disabled/n",
   part->name);
  goto out_register;
 }
 if (slave->offset + slave->mtd.size > master->size) {
  slave->mtd.size = master->size - slave->offset;
  printk(KERN_WARNING"mtd: partition /"%s/" extends beyond the end of device /"%s/" -- size truncated to %#llx/n",
   part->name, master->name, (unsigned long long)slave->mtd.size);
 }
 if (master->numeraseregions > 1) {
  /* Deal with variable erase size stuff */
  int i, max = master->numeraseregions;
  u64 end = slave->offset + slave->mtd.size;
  struct mtd_erase_region_info *regions = master->eraseregions;
  /* Find the first erase regions which is part of this
   * partition. */
  for (i = 0; i < max && regions[i].offset <= slave->offset; i++)
   ;
  /* The loop searched for the region _behind_ the first one */
  i--;
  /* Pick biggest erasesize */
  for (; i < max && regions[i].offset < end; i++) {
   if (slave->mtd.erasesize < regions[i].erasesize) {
    slave->mtd.erasesize = regions[i].erasesize;
   }
  }
  BUG_ON(slave->mtd.erasesize == 0);
 } else {
  /* Single erase size */
  slave->mtd.erasesize = master->erasesize;  // 分区擦除大小赋值
 }
 if ((slave->mtd.flags & MTD_WRITEABLE) &&
     mtd_mod_by_eb(slave->offset, &slave->mtd)) {
  /* Doesn't start on a boundary of major erase size */
  /* FIXME: Let it be writable if it is on a boundary of
   * _minor_ erase size though */
  slave->mtd.flags &= ~MTD_WRITEABLE;
  printk(KERN_WARNING"mtd: partition /"%s/" doesn't start on an erase block boundary -- force read-only/n",
   part->name);
 }
 if ((slave->mtd.flags & MTD_WRITEABLE) &&
     mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
  slave->mtd.flags &= ~MTD_WRITEABLE;
  printk(KERN_WARNING"mtd: partition /"%s/" doesn't end on an erase block -- force read-only/n",
   part->name);
 }
 slave->mtd.ecclayout = master->ecclayout;
 if (master->block_isbad) {
  uint64_t offs = 0;
  while (offs < slave->mtd.size) {
   if (master->block_isbad(master,
      offs + slave->offset))
    slave->mtd.ecc_stats.badblocks++; // 分区内坏块检查统计
   offs += slave->mtd.erasesize;
  }
 }
out_register:
 if (part->mtdp) {
  /* store the object pointer (caller may or may not register it*/
  *part->mtdp = &slave->mtd;
  slave->registered = 0;
 } else {
  /* register our partition */
  add_mtd_device(&slave->mtd);      // importment
  // 将该从分区作为MTD原始设备加入到mtd_table中，成功返回0
  // MTD原始设备层和MTD设备层就是依靠mtd_table来联系的
  slave->registered = 1;
 }
 return slave;
}
int add_mtd_device(struct mtd_info *mtd)
{
 int i;
 BUG_ON(mtd->writesize == 0);
 mutex_lock(&mtd_table_mutex);
 for (i=0; i < MAX_MTD_DEVICES; i++)
  if (!mtd_table[i]) {
   struct mtd_notifier *not;
   mtd_table[i] = mtd;   // 填充mtd_table[]数组，mtd原始设备层和mtd块设备层通过mtd_table[]联系在了一起
   mtd->index = i;     // mtd_table[]数组的下标赋给mtd->index
   mtd->usecount = 0;
   if (is_power_of_2(mtd->erasesize))
    mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
   else
    mtd->erasesize_shift = 0;
   if (is_power_of_2(mtd->writesize))
    mtd->writesize_shift = ffs(mtd->writesize) - 1;
   else
    mtd->writesize_shift = 0;
   mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
   mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
   /* Some chips always power up locked. Unlock them now */
   if ((mtd->flags & MTD_WRITEABLE)
       && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
    if (mtd->unlock(mtd, 0, mtd->size))
     printk(KERN_WARNING
            "%s: unlock failed, "
            "writes may not work/n",
            mtd->name);
   }
   DEBUG(0, "mtd: Giving out device %d to %s/n",i, mtd->name);
   /* No need to get a refcount on the module containing
      the notifier, since we hold the mtd_table_mutex */
   list_for_each_entry(not, &mtd_notifiers, list)
     not->add(mtd);        // 只要底层向上层添加一个mtd原始设备的话，那么就会遍历所有用户通知器
                    // 然后调用其add函数，再向mtd块设备层的上层通用磁盘层和block层注册。
                    // 对于mtdblock翻译层，其add_mtd函数指针指向mtdblock_add_mtd()
   mutex_unlock(&mtd_table_mutex);
   /* We _know_ we aren't being removed, because
      our caller is still holding us here. So none
      of this try_ nonsense, and no bitching about it
      either. :) */
   __module_get(THIS_MODULE);
   return 0;
  }
 mutex_unlock(&mtd_table_mutex);
 return 1;
}
//////////////////////////////////////////////////////////////////////////////////////////////
struct mtd_blktrans_dev {
 struct mtd_blktrans_ops *tr;
 struct list_head list;
 struct mtd_info *mtd;
 struct mutex lock;
 int devnum;
 unsigned long size;
 int readonly;
 void *blkcore_priv; /* gendisk in 2.5, devfs_handle in 2.4 */
};
static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
{
 struct mtd_blktrans_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 if (!dev)
  return;
 // 这里将分区作为的MTD设备联系在了一起，mtd_table
 dev->mtd = mtd;
 dev->devnum = mtd->index; // 分区表的索引值
 dev->size = mtd->size >> 9; // 该分区的大小以512为单位来计算
 dev->tr = tr;    // 操作集
 if (!(mtd->flags & MTD_WRITEABLE))
  dev->readonly = 1;
 add_mtd_blktrans_dev(dev);
 // 后面详解
}
int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
{
 struct mtd_blktrans_ops *tr = new->tr;
 struct mtd_blktrans_dev *d;
 int last_devnum = -1;
 struct gendisk *gd;
 if (mutex_trylock(&mtd_table_mutex)) {
  mutex_unlock(&mtd_table_mutex);
  BUG();
 }
 list_for_each_entry(d, &tr->devs, list) {
  if (new->devnum == -1) {
   /* Use first free number */
   if (d->devnum != last_devnum+1) {
    /* Found a free devnum. Plug it in here */
    new->devnum = last_devnum+1;
    list_add_tail(&new->list, &d->list);
    goto added;
   }
  } else if (d->devnum == new->devnum) {
   /* Required number taken */
   return -EBUSY;
   // 这里返回上层没有错误判断，因此也就没有释放掉上层函数开辟的struct mtd_blktrans_dev
   // 的内存空间，存在内存泄露，这里应该算是一个内核bug吧，不过呢，这个bug基本上是不会出现的
   // 如果你的分区不会动态被增加或者删除的话，这里就不会返回这个错误的 
  } else if (d->devnum > new->devnum) {
   /* Required number was free */
   list_add_tail(&new->list, &d->list);
   goto added;
  }
  last_devnum = d->devnum;
 }
 if (new->devnum == -1)
  new->devnum = last_devnum+1;
 if ((new->devnum << tr->part_bits) > 256) {
  return -EBUSY;
 }
 list_add_tail(&new->list, &tr->devs);
 // 翻译层操作集管理者所有属于该层的设备
 added:
 mutex_init(&new->lock);
 if (!tr->writesect)
  new->readonly = 1;
 gd = alloc_disk(1 << tr->part_bits);        // note 1
 // 分配gendisk结构体空间，并做一些初始的设置
 if (!gd) {
  list_del(&new->list);
  return -ENOMEM;
 }
 gd->major = tr->major;               // mtdblock  , 31
 gd->first_minor = (new->devnum) << tr->part_bits;  // mtd_table[]下标
 gd->fops = &mtd_blktrans_ops;            // 操作函数集
 if (tr->part_bits)  // 0
  if (new->devnum < 26)
   snprintf(gd->disk_name, sizeof(gd->disk_name),
     "%s%c", tr->name, 'a' + new->devnum);
  else
   snprintf(gd->disk_name, sizeof(gd->disk_name),
     "%s%c%c", tr->name,
     'a' - 1 + new->devnum / 26,
     'a' + new->devnum % 26);
 else
  snprintf(gd->disk_name, sizeof(gd->disk_name),
    "%s%d", tr->name, new->devnum);
                           // gd->disk_name = mtdblock{0 - 31}
 /* 2.5 has capacity in units of 512 bytes while still
    having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
 set_capacity(gd, (new->size * tr->blksize) >> 9);
 gd->private_data = new;
 new->blkcore_priv = gd;  // 互相指向对方
 gd->queue = tr->blkcore_priv->rq; // 该mtd设备的请求队列
 if (new->readonly)
  set_disk_ro(gd, 1);
 add_disk(gd);  // 向上层添加一个gendisk note2
 return 0;
}
/** note1 gd = alloc_disk(1) **/
struct gendisk *alloc_disk(int minors)
{
 return alloc_disk_node(minors, -1);  // note1-1
}
/**** note1-1  alloc_disk_node(1, -1) ****/
struct gendisk *alloc_disk_node(int minors, int node_id)
{
 struct gendisk *disk;
 disk = kmalloc_node(sizeof(struct gendisk),
    GFP_KERNEL | __GFP_ZERO, node_id);   // node_id就是NUMA系统中的节点号
 if (disk) {
  if (!init_part_stats(&disk->part0)) {
   kfree(disk);
   return NULL;
  }
  disk->node_id = node_id;          // -1
  if (disk_expand_part_tbl(disk, 0)) {
   free_part_stats(&disk->part0);
   kfree(disk);
   return NULL;
  }
  disk->part_tbl->part[0] = &disk->part0;
  disk->minors = minors;           // 1
  rand_initialize_disk(disk);
  disk_to_dev(disk)->class = &block_class;  // #define disk_to_dev(disk) (&(disk)->part0.__dev)
  disk_to_dev(disk)->type = &disk_type;
  device_initialize(disk_to_dev(disk));
  INIT_WORK(&disk->async_notify,
   media_change_notify_thread);
 }
 return disk;
}
/**** note1-1  alloc_disk_node(1, -1) ****/
/** note1 gd = alloc_disk(1) **/
/** note2 add_disk(gd) **/
void add_disk(struct gendisk *disk)
{
 struct backing_dev_info *bdi;
 dev_t devt;
 int retval;
 /* minors == 0 indicates to use ext devt from part0 and should
  * be accompanied with EXT_DEVT flag.  Make sure all
  * parameters make sense.
  */
 WARN_ON(disk->minors && !(disk->major || disk->first_minor));
 WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
 disk->flags |= GENHD_FL_UP;
 retval = blk_alloc_devt(&disk->part0, &devt);   // note2-1
 if (retval) {
  WARN_ON(1);
  return;
 }
 disk_to_dev(disk)->devt = devt;  // disk->part0.__dev->devt = devt
 // 主次设备号
 /* ->major and ->first_minor aren't supposed to be
  * dereferenced from here on, but set them just in case.
  */
 disk->major = MAJOR(devt);    // 31 
 disk->first_minor = MINOR(devt); // {0 - 31}
 blk_register_region(disk_devt(disk), disk->minors, NULL,
       exact_match, exact_lock, disk);
 register_disk(disk);       // note2-2
 blk_register_queue(disk);
 bdi = &disk->queue->backing_dev_info;
 bdi_register_dev(bdi, disk_devt(disk));
 retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
       "bdi");
 WARN_ON(retval);
}
/**** note2-1  blk_alloc_devt() ****/
int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
{
 struct gendisk *disk = part_to_disk(part);
 int idx, rc;
 
// part->partno = 0, disk->minors = 1, disk->major = 31, disk->first_minor = {0 - 31}
 /* in consecutive minor range? */
 if (part->partno < disk->minors) {
  *devt = MKDEV(disk->major, disk->first_minor + part->partno);  // 最后组织的主次设备号为31<<20 | {0 ~ 31}
  return 0;
 }
 /* allocate ext devt */      // 另外的方式来分配主次设备号
 do {
  if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
   return -ENOMEM;
  rc = idr_get_new(&ext_devt_idr, part, &idx);
 } while (rc == -EAGAIN);
 if (rc)
  return rc;
 if (idx > MAX_EXT_DEVT) {
  idr_remove(&ext_devt_idr, idx);
  return -EBUSY;
 }
 *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
 return 0;
}
/**** note2-1  blk_alloc_devt() ****/
/**** note2-2  register_disk(disk) ****/
void register_disk(struct gendisk *disk)
{
 struct device *ddev = disk_to_dev(disk);
 struct block_device *bdev;
 struct disk_part_iter piter;
 struct hd_struct *part;
 int err;
 ddev->parent = disk->driverfs_dev;
 dev_set_name(ddev, disk->disk_name);    // mtdblock{0 - 31}
 /* delay uevents, until we scanned partition table */
 ddev->uevent_suppress = 1;
 if (device_add(ddev))            // 将该设备添加到系统设备树中
  return;
#ifndef CONFIG_SYSFS_DEPRECATED
 err = sysfs_create_link(block_depr, &ddev->kobj,
    kobject_name(&ddev->kobj));
 if (err) {
  device_del(ddev);
  return;
 }
#endif
 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
 /* No minors to use for partitions */
 if (!disk_partitionable(disk))
  goto exit;
 /* No such device (e.g., media were just removed) */
 if (!get_capacity(disk))
  goto exit;
 bdev = bdget_disk(disk, 0);   // note2-2-1
 if (!bdev)
  goto exit;
 bdev->bd_invalidated = 1;
 err = blkdev_get(bdev, FMODE_READ); // 获取一次以验证
 if (err < 0)
  goto exit;
 blkdev_put(bdev, FMODE_READ);
exit:
 /* announce disk after possible partitions are created */
 ddev->uevent_suppress = 0;
 kobject_uevent(&ddev->kobj, KOBJ_ADD);
 /* announce possible partitions */
 disk_part_iter_init(&piter, disk, 0);
 while ((part = disk_part_iter_next(&piter)))
  kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
 disk_part_iter_exit(&piter);
}
/****** note2-2-1  bdev = bdget_disk(disk, 0) ******/
struct block_device *bdget_disk(struct gendisk *disk, int partno)
{
 struct hd_struct *part;
 struct block_device *bdev = NULL;
 part = disk_get_part(disk, partno);
 if (part)
  bdev = bdget(part_devt(part));  // note 2-2-1-1
  // 根据主次设备号得到block_device结构体
 disk_put_part(part);
 return bdev;
}
/******** note2-2-1-1  bdev = bdget(part_devt(part)) ********/
// fs/block_dev.c
struct bdev_inode {
 struct block_device bdev;
 struct inode vfs_inode;
};
static inline struct bdev_inode *BDEV_I(struct inode *inode)
{
 return container_of(inode, struct bdev_inode, vfs_inode);
}
inline struct block_device *I_BDEV(struct inode *inode)
{
 return &BDEV_I(inode)->bdev;
}
static inline unsigned long hash(dev_t dev)
{
 return MAJOR(dev)+MINOR(dev);
}
static int bdev_test(struct inode *inode, void *data)
{
 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
}
static int bdev_set(struct inode *inode, void *data)
{
 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
 return 0;
}
static LIST_HEAD(all_bdevs);
struct block_device *bdget(dev_t dev)
{
 struct block_device *bdev;
 struct inode *inode;
 inode = iget5_locked(blockdev_superblock, hash(dev),
   bdev_test, bdev_set, &dev);
 // 该函数最终会调用函数bdev_set()将dev的值赋值给BDEV_I(inode)->bdev.bd_dev
 if (!inode)
  return NULL;
 bdev = &BDEV_I(inode)->bdev;
 if (inode->i_state & I_NEW) {
  bdev->bd_contains = NULL;
  bdev->bd_inode = inode;  // inode关联到block_device结构体中
  bdev->bd_block_size = (1 << inode->i_blkbits);
  bdev->bd_part_count = 0;
  bdev->bd_invalidated = 0;
  inode->i_mode = S_IFBLK; // 对应的是块设备节点
  inode->i_rdev = dev;   // 主次设备号关联
  inode->i_bdev = bdev;   // block_device结构体关联
  
  /************************
  在使用mount挂载该设备上的文件系统时，例如上一篇文章中为了挂载nand分区中的yaffs2文件系统，那么系统是在哪个
  地方使用了注册时设置的这些信息呢？
  ...
  get_sb_bdev()
  --> open_bdev_exclusive()
    --> lookup_bdev()
      --> kern_path()
      --> bdev = bd_acquire(inode)
        这里只是取出了block_device结构体的指针
  而对于上面函数iget5_locked()-->bdev_set()中设置在对应block_device结构体中的主次设备号在文件系统挂载的时候
  ，在下面这个函数中获取到后存放在超级块中。
  ...
  get_sb_bdev()
  --> open_bdev_exclusive()
  --> sget()
    --> set_bdev_super()
      --> s->s_bdev = data;        // 就是open_bdev_exclusive()函数获得的block_device结构体
      --> s->s_dev = s->s_bdev->bd_dev;  // 主次设备号
  
  最后在yaffs2文件系统超级块填充函数yaffs_internal_read_super()中是这么使用的：
  ...
  if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
   return NULL; /* This isn't an mtd device */
  ...
  mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); // 取得对应的mtd_info结构体
  ...
  ************************/
  
  inode->i_data.a_ops = &def_blk_aops;
  mapping_set_gfp_mask(&inode->i_data, GFP_USER);
  inode->i_data.backing_dev_info = &default_backing_dev_info;
  spin_lock(&bdev_lock);
  list_add(&bdev->bd_list, &all_bdevs);
  spin_unlock(&bdev_lock);
  unlock_new_inode(inode);
 }
 return bdev;        // 返回这个block_device指针
}
/******** note2-2-1-1  bdev = bdget(part_devt(part)) ********/
/****** note2-2-1  bdev = bdget_disk(disk, 0) ******/
/**** note2-2  register_disk(disk) ****/
/** note2 add_disk(gd) **/
四、一点补充
static struct mtdblk_dev {
 struct mtd_info *mtd;
 int count;
 struct mutex cache_mutex;
 unsigned char *cache_data;
 unsigned long cache_offset;
 unsigned int cache_size;
 enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;
} *mtdblks[MAX_MTD_DEVICES];  // #define MAX_MTD_DEVICES 32
/*
** 这里是定义了一个指针数组，其中的每一个指针均指向一个struct mtdblk_dev
** 的类型的对象，每一个struct mtdblk_dev类型的对象都是一个MTD块设备，
** 这里的每一个指针指向的MTD块设备和mtd_table[]中元素指向的每一个
** struct mtd_info一一对应。
** 另外，可以看出linux最多支持32个MTD块设备
 
 关于mtdblks[]指针数组，我这里是以yaffs文件系统为例，所以是不会使用到这个指针数组的，应为yaffs它是建立在mtd原始设备层上，在其封装的函数内直接使用了mtd_info结构体内的函数，而没有经过mtdblock翻译层。如果我们的系统中使用的是mtd的其他接口，比如block device，那么就会使用到这个指针数组，在哪里使用呢？
 mtdblock.c文件中定义了mtdblock翻译层的操作集：
static struct mtd_blktrans_ops mtdblock_tr = {
 .name  = "mtdblock",
 .major  = 31,
 .part_bits = 0,
 .blksize  = 512,
 .open  = mtdblock_open,
 .flush  = mtdblock_flush,
 .release = mtdblock_release,
 .readsect = mtdblock_readsect,
 .writesect = mtdblock_writesect,
 .add_mtd = mtdblock_add_mtd,
 .remove_dev = mtdblock_remove_dev,
 .owner  = THIS_MODULE,
};
这些mtdblks[]的指针在哪里赋值的呢？请看函数mtdblock_open()中：
static int mtdblock_open(struct mtd_blktrans_dev *mbd)
{
 // mtd_blktrans_dev这个设备就是我们在初始化经过mtdblock翻译层向上层注册时的产物，表示了本层环境中的mtd设备
 // mbd->mtd在mtdblock_add_mtd()函数中被赋值，就是对应的mtd原始设备
 struct mtdblk_dev *mtdblk;
 struct mtd_info *mtd = mbd->mtd;
 int dev = mbd->devnum;
 DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open/n");
 if (mtdblks[dev]) {
  mtdblks[dev]->count++;
  return 0;
 } // 如果已经打开了，那么只需要增加引用计数
 /* OK, it's not open. Create cache info for it */
 mtdblk = kzalloc(sizeof(struct mtdblk_dev), GFP_KERNEL); // 否则，分配空间
 if (!mtdblk)
  return -ENOMEM;
 mtdblk->count = 1;  // 引用计数初始化成1
 mtdblk->mtd = mtd;  // 重要的联系
 mutex_init(&mtdblk->cache_mutex);
 mtdblk->cache_state = STATE_EMPTY;
 if ( !(mtdblk->mtd->flags & MTD_NO_ERASE) && mtdblk->mtd->erasesize) {
  mtdblk->cache_size = mtdblk->mtd->erasesize;
  mtdblk->cache_data = NULL;
 }
 mtdblks[dev] = mtdblk; // mtdblks指针数组中相应位置设置
 DEBUG(MTD_DEBUG_LEVEL1, "ok/n");
 return 0;
}

其实mtd块设备层和mtd原始设备层的分界线很明显，只是通过
 mtd_table[]和mtd_notifiers链表来联系，具体怎么联系的请参考上一篇文章。
 本文中将详细分析linux内核中nand设备注册和驱动注册，同时文中会穿插关于nand坏块管理的部分，另外在适当的地方会
 讲解DMA原理和其在nand驱动程序中的应用。
 
 * OS   : linux2.6.29
 * SOC  : pxa935
 * NAND : Hynix(512MB 1.8V 16-bit) - H8BCS0UN0MCR
 * Author: 李枝果/lizgo  2010-11-9  [e-mail]
 * note  : 本文中涉及的内容基本都是平台相关的，读者可只关注共性的东西

 2.6版本的linux内核驱动模型中流传着一个时髦的词：“platform”，其中也存在platform device和platform driver，
内核中使用platform bus统一管理这些设备和驱动，所以注册包括device和driver的注册。
一、platform device注册
 MACHINE_START和MACHINE_END定义的结构体是平台相关的，这里定义如下：
 MACHINE_START(BENZGLB, "Benzglb")
  .phys_io        = 0x40000000,
  .boot_params    = 0xa0000100,
  .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
  
  .map_io         = pxa_map_io,
  // start_kernel()-->setup_arch()-->paging_init()-->devicemaps_init()-->pxa_map_io
  .init_irq       = pxa3xx_init_irq,
  // 在setup_arch()中被赋值给全局函数指针init_arch_irq
  // start_kernel()-->init_IRQ()-->"init_arch_irq()"间接调用pxa3xx_init_irq
  .timer          = &pxa_timer,
  // 在setup_arch()中被赋值给全局struct sys_timer对象指针system_timer
  // start_kernel()-->time_init-->"system_timer->init()"间接调用pxa_timer.init = pxa_timer_init()
  .init_machine   = benzglb_init,
  // 在setup_arch()中被赋值给全局函数指针init_machine
  // 由于arch_initcall(customize_machine),所以在start_kernel()-->rest_init()
  // -->kernel_init()-->do_basic_setup()-->do_initcalls()的第3个等级上被调用
  // init.h
 MACHINE_END
 /*******************************
 其中的宏定义于文件：arch/arm/include/asm/mach/arch.h
 #define MACHINE_START(_type,_name)   /
 static const struct machine_desc __mach_desc_##_type /
  __used       /
  __attribute__((__section__(".arch.info.init"))) = { /
  .nr  = MACH_TYPE_##_type,  /
  .name  = _name,
 
 #define MACHINE_END    /
 };
 将上面的展开，实际上就是定义了一个结构体：
 static const struct machine_desc __mach_desc_BENZGLB   __used /
                  __attribute__((__section__(".arch.info.init"))) = {
                  .nr  = MACH_TYPE_BENZGLB,
                  .name  = "Benzglb",
                  .phys_io        = 0x40000000,
                    .boot_params    = 0xa0000100,
                    .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
                    .map_io         = pxa_map_io,
                    .init_irq       = pxa3xx_init_irq,
                    .timer          = &pxa_timer,
                    .init_machine   = benzglb_init,
                    };
 *******************************/
 benzglb_init()函数可谓是重量级的了，初始化了很多东西。但是是在哪里调用该函数的呢？或许从上面的注释你也可以
 注意到了，下面就再来wlak一下：
 start_kernel()
 --> setup_arch()
   --> ...
   --> init_machine = mdesc->init_machine;
   --> ...
   init_machine是文件arch/arm/kernel/setup.c中的静态全局变量，定义和调用如下：
   static void (*init_machine)(void) __initdata;
   static int __init customize_machine(void)
   {
    /* customizes platform devices, or adds new ones */
    if (init_machine)
     init_machine();
    return 0;
   }
   arch_initcall(customize_machine);    // init.h  initcall3
   可以看到customize_machine()函数将会在do_initcalls()的第3个等级上被调用，接着就会调用函数init_machine()，
   也就是函数benzglb_init():
 do_initcalls()
 --> customize_machine()
   --> init_machine() == benzglb_init()
     --> benzina_init_nand()       // 该函数中我们只关注nand初始化
       看来有必要将benzina_init_nand()全部列出来看一看了：
       static struct pxa3xx_nand_platform_data benzina_nand_info;
       /******
       struct pxa3xx_nand_platform_data {
        struct mtd_partition *parts;
        unsigned int    nr_parts;
       };
       ******/
       static void __init benzina_init_nand(void)
       {
        benzina_nand_info.parts = android_256m_v75_partitions;        // nand分区数组
        benzina_nand_info.nr_parts = ARRAY_SIZE(android_256m_v75_partitions); // nand分区数目
        
        pxa3xx_device_nand.dev.platform_data = &benzina_nand_info;
        platform_device_register(&pxa3xx_device_nand);
       }
       android_256m_v75_partitions定义于arch/arm/mach-pxa/include/mach/part_table.h中，这是一个
       struct mtd_partition类型结构体的数组，描述了系统上nand分区情况：name、offset、size等。
       pxa3xx_device_nand结构体对象是struct platform_device类型：
       static u64 pxa3xx_nand_dma_mask = DMA_BIT_MASK(32);
       static struct resource pxa3xx_resource_nand[] = {
        [0] = {
         .start = 0x43100000,
         .end = 0x431000ff,
         .flags = IORESOURCE_MEM,
        },
        [1] = {
         .start = IRQ_NAND,
         .end = IRQ_NAND,
         .flags = IORESOURCE_IRQ,
        },
       };
       
       struct platform_device pxa3xx_device_nand = {
        .name  = "pxa3xx-nand",
        .id  = -1,
        .dev  = {
         .dma_mask = &pxa3xx_nand_dma_mask,
         .coherent_dma_mask = DMA_BIT_MASK(32),
        },
        .resource = pxa3xx_resource_nand,   // see up
        .num_resources = ARRAY_SIZE(pxa3xx_resource_nand),
       };
       struct platform_device结构体的定义位于文件include/linux/platform_device.h中：
       struct platform_device {
        const char * name;
        int  id;
        struct device dev;
        u32  num_resources;
        struct resource * resource;
       };
       benzina_init_nand()函数中将描述nand分区的结构体benzina_nand_info与描述nand device的结构体
       联系起来：
       pxa3xx_device_nand.dev.platform_data = &benzina_nand_info;
       最后调用函数platform_device_register(&pxa3xx_device_nand)将nand的平台设备注册进系统的设备树内。
       对于注册的过程这里就不跟踪了，如果有兴趣，可参考我的另篇文章或自行分析。
二、platform driver注册
 该部分的内容位于文件drivers/mtd/nand/pxa3xx_nand.c
 static struct platform_driver pxa3xx_nand_driver = {
  .driver = {
   .name = "pxa3xx-nand",
  },
  .probe  = pxa3xx_nand_probe,
  .remove  = pxa3xx_nand_remove,
 #ifdef CONFIG_PM                // 电源管理的部分
  .suspend = pxa3xx_nand_suspend,
  .resume  = pxa3xx_nand_resume,
 #endif
 };
 static int __init pxa3xx_nand_init(void)
 {
  ...
  return platform_driver_register(&pxa3xx_nand_driver);
 }
 module_init(pxa3xx_nand_init); 
 这里说明一点：device和driver的注册其实是没有先后之分的，device注册的时候除了将自己挂在platform bus上外，另外
 会去遍历该bus上的所有drivers，直到匹配到(device和driver的名字相同)一个driver为止。而driver注册的时候，也是除
 了将自己挂在platfrom bus上之外，另外也会去遍历该bus上的所有设备区匹配，这里和前面不同的是，它会去找到多有该
 driver可以管理到的设备为止。下面就跟踪一下driver注册时，如何调用到probe函数的，又如何传递了
 struct platform_device的参数：
 platform_driver_register(&pxa3xx_nand_driver)
 --> drv->driver.bus = &platform_bus_type
 --> drv->driver.probe = platform_drv_probe
 --> ...
 --> driver_register(&drv->driver)
   --> driver_find(drv->name, drv->bus)    // 线检查是否已经注册过了
   --> bus_add_driver(drv)
     --> driver_attach(drv)
        --> bus_for_each_dev(drv->bus, NULL, drv, __driver_attach)
          --> fn(dev, data) = __driver_attach(dev, data) // dev - each device on platfrom bus
                                  // data - driver
            --> driver_probe_device(drv, dev)
              --> drv->bus->match(dev, drv) = platform_match(dev, drv) // 名字匹配
              --> really_probe(dev, drv)
                --> drv->probe(dev) = platform_drv_probe(dev)
                  --> static int platform_drv_probe(struct device *_dev)
                   {
                    struct platform_driver *drv = to_platform_driver(_dev->driver);
                    struct platform_device *dev = to_platform_device(_dev);
             
                    return drv->probe(dev);
                   }
                   -->pxa3xx_nand_probe(&pxa3xx_device_nand);
                   ...
                   到这个过程中，我们就还可以看到，driver注册的时候，会优先使用platform bus
                   的probe函数，如果它的probe函数为NULL，那么就使用注册driver的probe函数
                   (前提是要存在probe函数)
三、pxa3xx_nand_probe()函数分析
  由于内容加多，参见文档：pxa3xx_nand_probe.c
四、底层几个关键结构体的联系
static struct mtd_info *monahans_mtd = NULL;
struct nand_chip *this; 
struct pxa3xx_nand_info *info;
struct dfc_context dfc_context =
{
 .dfc_mode = &dfc_mode,
};
static struct dfc_flash_info hynix4GbX16 =
{
 .timing = {
  .tCH = 10,      /* tCH, Enable signal hold time */
  .tCS = 35,      /* tCS, Enable signal setup time */
  .tWH = 15,      /* tWH, ND_nWE high duration */
  .tWP = 25,      /* tWP, ND_nWE pulse time */
  .tRH = 15,      /* tRH, ND_nRE high duration */
  .tRP = 25,      /* tRP, ND_nRE pulse width */
  /* tR = tR+tRR+tWB+1, ND_nWE high to ND_nRE low for read */
  .tR = 25000,
  /* tWHR, ND_nWE high to ND_nRE low delay for status read */
  .tWHR = 60,
  .tAR = 10,      /* tAR, ND_ALE low to ND_nRE low delay */
 },
 .enable_arbiter = 1,    /* Data flash bus arbiter enable */
 .page_per_block = 64,   /* Pages per block */
 .row_addr_start = 1, /* third cycle start, Row address start position */
 .read_id_bytes = 4,     /* Returned ID bytes */
 .dfc_mode = 0,          /* NAND mode */
 .ncsx = 0,
 .page_size = 2048,      /* Page size in bytes */
 .oob_size = 64,         /* OOB size in bytes */
 .flash_width = 16,      /* Width of Flash memory */
 .dfc_width = 16,        /* Width of flash controller */
 .num_blocks = 4096,     /* Number of physical blocks in Flash */   //modified sunqidong
 .chip_id =  0xbcad,                         //modified sunqidong
 .read_prog_cycles = 5, /* Read, Program Cycles */
 /* command codes */
 .read1 = 0x3000,        /* Read */
 .read2 = 0x0050,        /* Read1 unused, current DFC don't support */
 .program = 0x1080,      /* Write, two cycle command */       //modified sunqidong
 .read_status = 0x0070,  /* Read status */
 .read_id = 0x0090,      /* Read ID */
 .erase =  0xD060,       /* Erase, two cycle command */
 .reset = 0x00FF,        /* Reset */
 .lock = 0x002A,         /* Lock whole flash */
 .unlock = 0x2423, /* Unlock, two cycle command, supporting partial unlock */
 .lock_status = 0x007A,  /* Read block lock status */
 .addr2ndcb1 = HYNIX4GbX16Addr2NDCB1,
 .ndbbr2addr = HYNIX4GbX16NDBBR2Addr,
};
///////////////////////// 这几个底层关键结构体的联系 ////////////////////////////
context->flash_info = &hynix4GbX16
// 分配mtd_info、nand_chip、pxa3xx_nand_info的空间
monahans_mtd = kzalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip) +
   sizeof(struct pxa3xx_nand_info) , GFP_KERNEL);
...
this = (struct nand_chip *)((void *)monahans_mtd + sizeof(struct mtd_info));
info = (struct pxa3xx_nand_info *)((void *)this + sizeof(struct nand_chip));
...
monahans_mtd->priv = this;
this->priv = info;
...
info->context = &dfc_context
...