Linux-Nand Flash驱动(分析MTD层并制作NAND驱动)

static int __init s3c2410_nand_init(void)
{
       printk("S3C24XX NAND Driver, (c) 2004 Simtec Electronics\n");
       platform_driver_register(&s3c2412_nand_driver);　　　　 
       platform_driver_register(&s3c2440_nand_driver);　　　　 

       return platform_driver_register(&s3c2410_nand_driver);
}

static int s3c24xx_nand_probe(struct platform_device *pdev, enum s3c_cpu_type cpu_type)
{
... ...

err = s3c2410_nand_inithw(info, pdev);       //初始化硬件hardware,设置TACLS 、TWRPH0、TWRPH1通信时序等

s3c2410_nand_init_chip(info, nmtd, sets);    //初始化芯片

nmtd->scan_res = nand_scan(&nmtd->mtd, (sets) ? sets->nr_chips : 1); //3.扫描nandflash
... ...
s3c2410_nand_add_partition(info, nmtd, sets);         //4.调用add_mtd_partitions()来添加mtd分区
... ...
}

static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,struct nand_chip *chip,int busw, int *maf_id)
{
 struct nand_flash_dev *type = NULL;
 int i, dev_id, maf_idx;
 chip->select_chip(mtd, 0);     //调用nand_chip结构体的成员select_chip使能flash片选

 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); //3.2调用nand_chip结构体的成员cmdfunc,发送读id命令,最后数据保存在mtd结构体里

 *maf_id = chip->read_byte(mtd); // 获取厂家ID，

  dev_id = chip->read_byte(mtd);   //获取设备ID

   /* 3.3for循环匹配nand_flash_ids[]数组,找到对应的nandflash信息*/
     for (i = 0; nand_flash_ids[i].name != NULL; i++) 
   {  
         if (dev_id == nand_flash_ids[i].id) 　　　　//匹配设备ID
         {type =  &nand_flash_ids[i];
           break;}
　　}
       ... ...

/* 3.4 匹配成功,便打印nandflash参数   */
printk(KERN_INFO "NAND device: Manufacturer ID:"
                     " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
                     dev_id, nand_manuf_ids[maf_idx].name, mtd->name);  
       ... ...
}

int add_mtd_partitions(struct mtd_info *master, const struct mtd_partition *parts,int nbparts);　　//创建多个分区mtd设备
//函　数　成　员　介　绍　: 
//master:就是要创建的mtd设备
//parts:分区信息的数组,它的结构体是mtd_partition,该结构体如下所示:
/*
struct mtd_partition {
       char *name;                  //分区名,比如bootloader、params、kernel、root
       u_int32_t size;               //分区大小
       u_int32_t offset;            //分区所在的偏移值
       u_int32_t mask_flags;            //掩码标志
       struct nand_ecclayout *ecclayout; //OOB布局
       struct mtd_info **mtdp;              //MTD的指针,不常用
};
*/
//nbparts:等于分区信息的数组个数,表示要创建分区的个数 

int add_mtd_device(struct mtd_info *mtd)    //创建一个mtd设备
{
 struct list_head *this;
 ... ...
    list_for_each(this, &mtd_notifiers)     //4.3找mtd_notifiers链表里的list_head结构体
  {
   struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list); //通过list_head找到struct mtd_notifier *not
   not->add(mtd);    　　　　　　　　//最后调用mtd_notifier 的add()函数
  }
 ... ...
} 

static int __init init_mtdchar(void)
{

       /*创建字符设备mtd,主设备号为90 ,cat /proc/devices 可以看到 */
       if (register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops)) {
          printk(KERN_NOTICE "Can‘t allocate major number %d for Memory Technology Devices.\n",MTD_CHAR_MAJOR);
          return -EAGAIN;
       }

       mtd_class = class_create(THIS_MODULE, "mtd");              //创建类

       if (IS_ERR(mtd_class)) {
              printk(KERN_ERR "Error creating mtd class.\n");
              unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
              return PTR_ERR(mtd_class);
       }

       register_mtd_user(&notifier);              //调用register_mtd_user(),将notifier添加到mtd_notifiers链表中

       return 0;
}

static void mtd_notify_add(struct mtd_info* mtd)
{
       if (!mtd)
              return;

       /*其中MTD_CHAR_MAJOR主设备定义为90 */
       class_device_create(mtd_class, NULL, MKDEV(MTD_CHAR_MAJOR, mtd->index*2),NULL, "mtd%d", mtd->index);
                                                        //创建mtd%d字符设备节点

       class_device_create(mtd_class, NULL,MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1),NULL, "mtd%dro", mtd->index);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //创建mtd%dro字符设备节点

}

static void blktrans_notify_add(struct mtd_info *mtd)
{
       struct list_head *this;

       if (mtd->type == MTD_ABSENT)
              return;
 
       list_for_each(this, &blktrans_majors) //找blktrans_majors链表里的list_head结构体
　　　　{
        struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);
        tr->add_mtd(tr, mtd);    // 执行mtd_blktrans_ops结构体的add_mtd()
       }
}

int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
       ... ...
ret = register_blkdev(tr->major, tr->name);              //注册块设备
tr->blkcore_priv->rq=blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
                                                                             //分配一个请求队列
... ...
       list_add(&tr->list, &blktrans_majors);                //将tr->list 添加到blktrans_majors链表
}

int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
{
       ... ...
       gd = alloc_disk(1 << tr->part_bits);                  //分配一个gendisk结构体

       gd->major = tr->major;                                //设置gendisk的主设备号

       gd->first_minor = (new->devnum) << tr->part_bits;      //设置gendisk的起始此设备号

       gd->fops = &mtd_blktrans_ops;                         //设置操作函数
       ... ...        

       gd->queue = tr->blkcore_priv->rq;           //设置请求队列

       add_disk(gd);                                           //向内核注册gendisk结构体
}

struct nand_chip {
　　　　void  __iomem      *IO_ADDR_R;         /* 需要读出数据的nandflash地址 */
　　　　void  __iomem      *IO_ADDR_W;        /* 需要写入数据的nandflash地址 */ 

       /* 从芯片中读一个字节 */
       uint8_t    (*read_byte)(struct mtd_info *mtd);           
       /* 从芯片中读一个字 */
       u16         (*read_word)(struct mtd_info *mtd);         
       /* 将缓冲区内容写入nandflash地址, len:数据长度*/
       void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len); 
       /* 读nandflash地址至缓冲区, len:数据长度   */
       void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
       /* 验证芯片和写入缓冲区中的数据 */
       int          (*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
　　　　/* 选中芯片,当chip==0表示选中,chip==-1时表示取消选中 */
　　　　void (*select_chip)(struct mtd_info *mtd, int chip);
       /* 检测是否有坏块 */
       int          (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip);
       /* 标记坏块 */
       int          (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
　　　　/* 命令、地址控制函数 ,  dat :要传输的命令/地址 */
　　　　/*当ctrl=2表示要发送的dat是命令,否则就是dat就是地址*/
　　　　void (*cmd_ctrl)(struct mtd_info *mtd, int dat,unsigned int ctrl);
　　　　/* 设备是否就绪,当该函数返回的RnB引脚的数据等于1,表示nandflash已就绪 */
　　　　int (*dev_ready)(struct mtd_info *mtd);
　　　　/* 实现命令发送,最终调用nand_chip -> cmd_ctrl来实现  */
       void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
       /*等待函数,通过nand_chip ->dev_ready来等待nandflash是否就绪 */
       int          (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
       /* 擦除命令的处理 */
       void (*erase_cmd)(struct mtd_info *mtd, int page);
       /* 扫描坏块 */
       int          (*scan_bbt)(struct mtd_info *mtd);
       int          (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
       /* 写一页 */
       int          (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,const uint8_t *buf, int page, int cached, int raw);

       int          chip_delay;                   /* 由板决定的延迟时间 */

       /* 与具体的NAND芯片相关的一些选项，默认为8位宽nand,
　   　比如设置为NAND_BUSWIDTH_16,表示nand的总线宽为16 */
       unsigned int   options; 


       /* 用位表示的NAND芯片的page大小，如某片NAND芯片
        * 的一个page有512个字节，那么page_shift就是9
        */
       int          page_shift;

       /* 用位表示的NAND芯片的每次可擦除的大小，如某片NAND芯片每次可
        * 擦除16K字节(通常就是一个block的大小)，那么phys_erase_shift就是14
        */
       int          phys_erase_shift;

       /* 用位表示的bad block table的大小，通常一个bbt占用一个block，
        * 所以bbt_erase_shift通常与phys_erase_shift相等
        */
       int          bbt_erase_shift;
       /* 用位表示的NAND芯片的容量 */
       int          chip_shift;
       /* NADN FLASH芯片的数量 */
       int          numchips;
       /* NAND芯片的大小 */
       uint64_t chipsize;

       int          pagemask;
       int          pagebuf;
       int          subpagesize;
       uint8_t    cellinfo;
       int          badblockpos;
       nand_state_t   state;
       uint8_t           *oob_poi;
       struct nand_hw_control  *controller;
       struct nand_ecclayout   *ecclayout;     /* ECC布局 */
/* ECC校验结构体,若不设置, ecc.mode默认为NAND_ECC_NONE(无ECC校验) */
/*可以为硬件ECC和软件ECC校验,比如:设置ecc.mode=NAND_ECC_SOFT(软件ECC校验)*/
　　　　struct nand_ecc_ctrl ecc;      
       struct nand_buffers *buffers;
       struct nand_hw_control hwcontrol;
       struct mtd_oob_ops ops;
       uint8_t           *bbt;
       struct nand_bbt_descr   *bbt_td;
       struct nand_bbt_descr   *bbt_md;
       struct nand_bbt_descr   *badblock_pattern;
       void        *priv;
};

int nand_scan(struct mtd_info *mtd, int maxchips);   //扫描nandflash,扫描成功返回0

int add_mtd_partitions(struct mtd_info *master,const struct mtd_partition *parts,int nbparts);
//将nandflash分成nbparts个分区,会创建多个MTD字符/块设备,成功返回0
//master:就是要创建的mtd设备
//parts:分区信息的数组,它的结构体是mtd_partition
//nbparts:要创建分区的个数,比如上图,那么就等于4

int del_mtd_partitions(struct mtd_info *master);
//卸载分区,并会卸载MTD字符/块设备

#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/clk.h> 
#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/nand_ecc.h>
#include <linux/mtd/partitions.h>
#include <asm/io.h> 
#include <asm/arch/regs-nand.h>
#include <asm/arch/nand.h>

struct  mynand_regs {
    unsigned long nfconf  ;             //0x4E000000
    unsigned long nfcont  ;
    unsigned long nfcmd   ;
    unsigned long nfaddr  ;
    unsigned long nfdata  ;
    unsigned long nfeccd0 ;
    unsigned long nfeccd1 ;
    unsigned long nfeccd  ;
    unsigned long nfstat  ;
    unsigned long nfestat0;
    unsigned long nfestat1;
    unsigned long nfmecc0 ;
    unsigned long nfmecc1 ;
    unsigned long nfsecc  ;
    unsigned long nfsblk  ;
    unsigned long nfeblk  ;
};
static struct mynand_regs *my_regs;              //nand寄存器
static struct mtd_info *my_mtd;
static struct nand_chip *mynand_chip;      

static struct mtd_partition mynand_part[] = {
    [0] = {
        .name   = "bootloader",
        .size   = 0x00040000,
        .offset    = 0,
    },
    [1] = {
        .name   = "params",
        .offset = MTDPART_OFS_APPEND,
        .size   = 0x00020000,
    },
    [2] = {
        .name   = "kernel",
        .offset = MTDPART_OFS_APPEND,
        .size   = 0x00200000,
    },
    [3] = {
        .name   = "root",
        .offset = MTDPART_OFS_APPEND,
        .size   = MTDPART_SIZ_FULL,
    }
};

  /*nand flash  :CE */
static void mynand_select_chip(struct mtd_info *mtd, int chipnr)
{
        if(chipnr==-1)          //CE Disable
       {
        my_regs->nfcont|=(0x01<<1);               //bit1置1
       }
        else                         //CE Enable
       {
        my_regs->nfcont&=~(0x01<<1);        //bit1置0  
       }            
}
   /*命令/地址控制函数 */
static void mynand__cmd_ctrl(struct mtd_info *mtd, int dat, unsigned int ctrl)
{
    if (ctrl & NAND_CLE)                              //当前为command状态 ,   
          my_regs->nfcmd=dat;   
    else                   //当前为地址状态 ,  if  (ctrl & NAND_ALE)   
         my_regs->nfaddr=dat;
}

/* nand flash 设备就绪函数(获取RnB引脚状态 */
static int mynand__device_ready(struct mtd_info *mtd)
{
    return (my_regs->nfstat&0x01);                //获取RnB状态,0:busy       1:ready
}


    /*init入口函数*/
static int mynand_init(void)
{
    struct clk *nand_clk;
    int res;
   /*1.分配结构体: mtd_info和nand_chip */
   my_mtd=kzalloc(sizeof(struct mtd_info), GFP_KERNEL);      
   mynand_chip=kzalloc(sizeof(struct nand_chip), GFP_KERNEL);
    
    /*2.获取nand flash 寄存器虚拟地址*/
     my_regs=ioremap(0x4E000000, sizeof(struct mynand_regs));

    /*3.设置mtd_info*/
    my_mtd->owner=THIS_MODULE;
    my_mtd->priv=mynand_chip;                    //私有数据

    /*4.设置nand_chip*/
    mynand_chip->IO_ADDR_R=&my_regs->nfdata;                 //设置读data
    mynand_chip->IO_ADDR_W=&my_regs->nfdata;                 //设置写data
    mynand_chip->select_chip=mynand_select_chip;             //设置CE 
    mynand_chip->cmd_ctrl = mynand__cmd_ctrl;                //设置写command/address
    mynand_chip->dev_ready = mynand__device_ready;           //设置RnB
    mynand_chip->ecc.mode = NAND_ECC_SOFT;                   //设置软件ECC


    /*5.设置硬件相关*/    
        /*5.1使能nand flash 时钟*/
        nand_clk=clk_get(NULL,"nand");
        clk_enable(nand_clk); 

        /*5.2设置时序*/
        #define TACLS       0                    //0nS
        #define TWRPH0   1                       //15nS
        #define TWRPH1   0                       //5nS
        my_regs->nfconf = (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4);

        /*5.3       bit1:关闭片选,       bit0:开启nand flash 控制器*/
        my_regs->nfcont=(1<<1)|(1<<0);
    
    /*6.扫描NAND*/
    if (nand_scan(my_mtd, 1)) {                   // 1:表示只扫描一个nand flash 设备
        res = -ENXIO;
        goto out;
    }
            
    /*7.添加分区,创建字符/块设备*/
    res = add_mtd_partitions(my_mtd, mynand_part, 4); 
    if(res)
　　　　return 0;

out:
    del_mtd_partitions(my_mtd);                 　　　　 //卸载分区,卸载字符/块设备
    kfree(my_mtd);                                      //释放mtd
    iounmap(my_regs);                                //释放nand flash寄存器
    kfree(mynand_chip);                             //释放nand_chip
    return 0;
    
}

/*exit出口函数*/
static void mynand_exit(void)
{
    del_mtd_partitions(my_mtd);     //卸载分区,卸载字符/块设备
    kfree(my_mtd);                          //释放mtd
    iounmap(my_regs);                    //释放nand flash寄存器
    kfree(mynand_chip);                 //释放nand_chip
}

module_init(mynand_init);
module_exit(mynand_exit);
MODULE_LICENSE("GPL");

< >   NAND Flash support for S3C2410/S3C2440 SoC    //去掉默认的nandflash驱动

mount /dev/mtdblock3        /mnt/             //挂载, mount会自动获取该设备的文件类型

tar -xjf mtd-utils-05.07.23.tar.bz2       　　　 //解压mtd-util工具
cd mtd-utils-05.07.23/util /                 　 //进入util目录
vi Makefile                                     //修改交叉编译改为: CROSS=arm-linux-
make                                          //编译,生成flashcp 、flash_erase、flash_eraseall等命令
cp  flash_erase  flash_eraseall  /nfs文件系统目录   //复制命令

./flashcp   fs.yaffs2  /dev/mtd0      //将文件系统yaffs2复制到mtd0中

./flash_erase  /dev/mtd0 0x20000 5   //擦除mtd0从0x20000开始的5块数据 ,128K/块

./flash_eraseall  /dev/mtd0        //擦除mtd0

umount /mnt                                             //擦除之前需要使用umount mnt来取消之前的挂载
./flash_eraseall  /dev/mtd3                             //擦除mtd3
mount -t yaffs /dev/mtdblock3 /mnt/                     //使用yaffs类型来挂载mtdblock3块设备
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//因为当前的mtdblock3为空,mount命令无法自动获取mtdblock3的文件类型