20150311 NandFlash驱动分析

20150311 NandFlash驱动分析

2015-03-11 李海沿

一、结构体详解

MTD体系结构:

在linux中提供了MTD(Memory Technology Device,内存技术设备)系统来建立Flash针对linux的统一、抽象的接口

引入MTD后,linux系统中的Flash设备驱动及接口可分为4层:

设备节点

MTD设备层

MTD原始设备层

硬件驱动层

硬件驱动层:Flash硬件驱动层负责底层硬件设备实际的读、写、擦除,Linux MTD设备的NAND型Flash驱动位于driver/mtd/nand子目录下

s3c2410对应的nand Flash驱动为s3c2410.c

MTD原始设备层:MTD原始设备层由两部分构成,一部分是MTD原始设备的通用代码,另一部分是各个特定Flash的数据,比如分区

主要构成的文件有:

drivers/mtd/mtdcore.c 支持mtd字符设备

driver/mtd/mtdpart.c 支持mtd块设备

MTD设备层:基于MTD原始设备,Linux系统可以定义出MTD的块设备(主设备号31) 和字符设备(设备号90),构成MTD设备层

简单的说就是:使用一个mtd层来作为具体的硬件设备驱动和上层文件系统的桥梁。mtd给出了系统中所有mtd设备(nand,nor,diskonchip)的统一组织方式。

1. struct mtd_info *

mtd层用一个数组struct mtd_info *mtd_table[MAX_MTD_DEVICES]保存系统中所有的设备,mtd设备利用struct mtd_info 这个结构来描述,该结构中描述了存储设备的基本信息和具体操作所需要的内核函数,mtd系统的那个机制主要就是围绕这个结构来实现的。结构体在include/linux/mtd/mtd.h中定义:


struct mtd_info {

u_char type; //MTD 设备类型

u_int32_t flags; //MTD设备属性标志

u_int32_t size; //标示了这个mtd设备的大小

u_int32_t erasesize; //MTD设备的擦除单元大小,对于NandFlash来说就是Block的大小

u_int32_t oobblock; //oob区在页内的位置,对于512字节一页的nand来说是512

u_int32_t oobsize; //oob区的大小,对于512字节一页的nand来说是16

u_int32_t ecctype; //ecc校验类型

u_int32_t eccsize; //ecc的大小

char *name; //设备的名字

int index; //设备在MTD列表中的位置

struct nand_oobinfo oobinfo; //oob区的信息,包括是否使用ecc,ecc的大小

//以下是关于mtd的一些读写函数,将在nand_base中的nand_scan中重载

int (*erase)

int (*read)

int (*write)

int (*read_ecc)

int (*write_ecc)

int (*read_oob)

int (*read_oob)

void *priv;//设备私有数据指针,对于NandFlash来说指nand芯片的结构

}

2. struct nand_chip

下面看nand_chip结构,nand_chip主要是定义了一写操作函数,在include/linux/mtd/nand.h中定义:


struct nand_chip {

void __iomem *IO_ADDR_R; //这是nandflash的读写寄存器

void __iomem *IO_ADDR_W;

//以下都是nandflash的操作函数,这些函数将根据相应的配置进行重载

u_char (*read_byte)(struct mtd_info *mtd);

void (*write_byte)(struct mtd_info *mtd, u_char byte);

u16 (*read_word)(struct mtd_info *mtd);

void (*write_word)(struct mtd_info *mtd, u16 word);

void (*write_buf)(struct mtd_info *mtd, const u_char *buf, int len);

void (*read_buf)(struct mtd_info *mtd, u_char *buf, int len);

int (*verify_buf)(struct mtd_info *mtd, const u_char *buf, int len);

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);

void (*hwcontrol)(struct mtd_info *mtd, int cmd);

int (*dev_ready)(struct mtd_info *mtd);

void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);

int (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this, int state);

int (*calculate_ecc)(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);

int (*correct_data)(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);

void (*enable_hwecc)(struct mtd_info *mtd, int mode);

void (*erase_cmd)(struct mtd_info *mtd, int page);

int (*scan_bbt)(struct mtd_info *mtd);

int eccmode; //ecc的校验模式(软件,硬件)

int chip_delay; //芯片时序延迟参数

int page_shift; //页偏移,对于512B/页的,一般是9

u_char *data_buf; //数据缓存区

}

跟NAND操作相关的函数:

1、 nand_base.c:

定义了NAND驱动中对NAND芯片最基本的操作函数和操作流程,如擦除、读写page、读写oob等。当然这些函数都只是进行一些常规的操作,若你的系统在对NAND操作时有一些特殊的动作,则需要在你自己的驱动代码中进行定义。

2、 nand_bbt.c:

定义了NAND驱动中与坏块管理有关的函数和结构体。

3、 nand_ids.c:

定义了两个全局类型的结构体:struct nand_flash_dev nand_flash_ids[ ]和struct nand_manufacturers nand_manuf_ids[ ]。其中前者定义了一些NAND芯片的类型,后者定义了NAND芯片的几个厂商。NAND芯片的ID至少包含两项内容:厂商ID和厂商为自己的NAND芯片定义的芯片ID。当NAND加载时会找这两个结构体,读出ID,如果找不到,就会加载失败。

4、 nand_ecc.c:

定义了NAND驱动中与softeware ECC有关的函数和结构体,若你的系统支持hardware ECC,且不需要software ECC,则该文件也不需理会。

二、驱动程序解析

1. 定义结构体

如图所示,

①定义了芯片寄存器的一些指针,便于程序中直接使用

②定义了nand_chip结构体,功能是定义了一些读写操作函数,读写寄存器等

③定义了存储设备的基本信息和具体的操作所需要的内核函数

2.在初始化函数中初始化nand_chip结构体

如图所示:

①分配一个nand_chip结构体所需的内存

②映射芯片的寄存器地址到nand_chip结构体

③初始nand_chip结构体中的函数指针

3.定义nand_flash时钟

如图所示:

首先从内核中找到nand的时钟信息,根据芯片手册设置读写时钟脉冲信号。

4.设置nand_mtd结构体

mtd设备利用struct mtd_info 这个结构来描述,该结构中描述了存储设备的基本信息和具体操作所需要的内核函数

在130行中,将我们的nand_mtd结构体与nand_chip结构体联系在一起。

5.实现片选函数

6.实现命令控制函数,用于发送地址和数据

7.在exit函数中释放相应的内存

8.总结流程

①:定义nand_chip结构体实现读写等操作函数

②:初始nand_flash相关的时钟,以及初始化nand_flash的数据时钟总脉冲信号

③:初始化nand_mtd结构体,用于保存扫描得到的nandflash的相关信息

实现了以上三步就可以大致实现了nand-flash的简易驱动程序了

初始化后,实现对nand的基本硬件操作就可以了,包括以下函数:

s3c2410_nand_inithw //初始化硬件,在probe中调用

s3c2410_nand_select_chip //片选

s3c2440_nand_hwcontrol //硬件控制,其实就是片选

s3c2440_nand_devready //设备就绪

s3c2440_nand_enable_hwecc //使能硬件ECC校验

s3c2440_nand_calculate_ecc //计算ECC

s3c2440_nand_read_buf s3c2440_nand_write_buf

9.加载

insmod nand_dev.ko

附驱动源程序1

  1 #include <linux/module.h>
  2 #include <linux/types.h>
  3 #include <linux/init.h>
  4 #include <linux/kernel.h>
  5 #include <linux/string.h>
  6 #include <linux/ioport.h>
  7 #include <linux/platform_device.h>
  8 #include <linux/delay.h>
  9 #include <linux/err.h>
 10 #include <linux/slab.h>
 11 #include <linux/clk.h>
 12 #include <linux/cpufreq.h>
 13
 14 #include <linux/mtd/mtd.h>
 15 #include <linux/mtd/nand.h>
 16 #include <linux/mtd/nand_ecc.h>
 17 #include <linux/mtd/partitions.h>
 18
 19 #include <asm/io.h>
 20
 21 #include <plat/regs-nand.h>
 22 #include <plat/nand.h>
 23 //nand falsh寄存器列表结构体
 24 struct nand_regs {
 25     unsigned long nfconf;
 26     unsigned long nfcont;
 27     unsigned long nfcmmd;
 28     unsigned long nfaddr;
 29     unsigned long nfdata;
 30     unsigned long nfmeccd0;
 31     unsigned long nfmeccd1;
 32     unsigned long nfseccd;
 33     unsigned long nfsblk;
 34     unsigned long nfeblk;
 35     unsigned long nfstat;
 36     unsigned long nfeccerr0;
 37     unsigned long nfeccerr1;
 38 };
 39
 40 static struct nand_regs *nand_regs;           //nand flash 结构体,主要是定义了芯片寄存器的地址
 41 static struct nand_chip *tiny_nand_chip;    //主要定义了一些读写打开等操作函数
 42 static struct mtd_info *tiny_nand_mtd         //描述了存储设备的基本信息和具体操作所需要的内核函数
 43
 44 //芯片选择函数
 45 static void tiny_nand_select_chip(struct mtd_info *mtd, int chipnr)
 46 {
 47     if(chipnr == -1)
 48     {
 49         /*取消选择  NFCONT[1]设为1*/
 50         nand_regs->nfcont |= (1<<1);
 51     }
 52     else
 53     {
 54         /*选中芯片  NFCONT[1]设为0*/
 55         nand_regs->nfcont &= ~(1<<1);
 56     }
 57 }
 58
 59 //命令控制,数据发送函数
 60 static void tiny_nand_cmd_ctrl(struct mtd_info *mtd, int dat,
 61                 unsigned int ctrl)
 62 {
 63
 64     if (ctrl & NAND_CLE)
 65     {
 66         /*发命令  NFCMMD = dat*/
 67         nand_regs->nfcmmd = dat;
 68     }
 69     else
 70     {
 71         /*发地址  NFADDR = dat*/
 72         nand_regs->nfaddr = dat;
 73     }
 74 }
 75
 76 static int tiny_nand_dev_ready(struct mtd_info *mtd, struct nand_chip *chip)
 77 {
 78     /*等待命令的操作完成*/
 79     return (nand_regs->nfstat & (1<<0));
 80 }
 81
 82 static int tiny_nand_init(void)
 83 {
 84     struct clk *nand_clk;
 85     /*1.分配一个nand_chip结构体,主要定义了一些操作函数*/
 86     tiny_nand_chip = kzalloc(sizeof(struct nand_chip),GFP_KERNEL);     //分配nand_chip结构体内存
 87     nand_regs = ioremap(0xB0E00000,sizeof(struct nand_regs));        //映射nand_chip结构体地址
 88
 89     /*2.设置*/
 90     /*
 91      * 初始化nand_chip结构体中的函数指针,设置nand_chip 是给nand_scan函数使用的,
 92      * 如果不知道咋么设置先看nand_scan怎么使用
 93      * 提供选中芯片,发命令,发地址,读数据,写数据,等待等操作
 94      */
 95     tiny_nand_chip->select_chip    = tiny_nand_select_chip; //nand片选控制函数
 96     tiny_nand_chip->cmd_ctrl        = tiny_nand_cmd_ctrl;    //命令控制函数,包括数据和地址命令的发送
 97     tiny_nand_chip->IO_ADDR_R   = &nand_regs->nfdata;        //nandflash的读寄存器
 98     tiny_nand_chip->IO_ADDR_W  = &nand_regs->nfdata;        //nandflash的写寄存器
 99     tiny_nand_chip->dev_ready     = tiny_nand_dev_ready;    //nand准备完毕,可以开始读写, GPIO_RDY        8
100     tiny_nand_chip->ecc.mode      = NAND_ECC_SOFT;            ////ecc的校验模式(软件,硬件)
101     /*3.硬件相关*/
102     /*使能时钟*/
103     nand_clk = clk_get(NULL, "nand");        //从内核中找到nand的时钟信息,通过名字匹配
104     clk_enable(nand_clk);                    //时能nandflash的时钟
105
106     /*
107      * AddrCycle[1]:1 = 发送地址需要5个周期
108      */
109     nand_regs->nfconf |= 1<<1;        //取消片选
110     //HCLK = 100MHz
111     //TACLS : 发出CLE/ALE之后多长时间才发出nWE信号,
112     //    从NAND手册克制CLE/ALE与nWE可以同时faculty,所以TACLS = 0
113     //TWRPH0:nWE的脉冲宽度,HCLK x(TWRPH0 + 1),
114     //    从NAND手册克制它要>=12ns,    所以TWRPH0 >= 1
115     //TWRPH1: nWE变为高电平后多长时间CLE/ALE才能变为低电平,
116     //    从NAND手册值要>=5ns,        所以TWRPH1 >= 0
117 #define TWRPH1       0    //1
118 #define TWRPH0       1
119 #define TACLS        0    //1
120     nand_regs->nfconf |= (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4); //设置脉冲信号
121     /*
122      * MODE[0]:1     = 使能Nand Flash控制器
123      * Reg_nCE0[1]:1 = 取消片选
124      */
125     nand_regs->nfcont |= (1<<1)|(1<<0);    //时能nandflash控制器,取消片选
126     /*4.使用*/
127     tiny_nand_mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); //申请mtd_info结构体内存
128     tiny_nand_mtd->owner = THIS_MODULE;
129     tiny_nand_mtd->priv = tiny_nand_chip;        //设置设备私有数据指针,绑定前面的nand_chip结构体
130
131     nand_scan(tiny_nand_mtd, 1);    //扫描识别nand flash ,构造mtd_info结构体
132
133 }
134
135 static void tiny_nand_exit(void)
136 {
137     kfree(tiny_nand_mtd);        //释放mtd结构体的内存
138     iounmap(nand_regs);            //取消地址映射
139     kfree(tiny_nand_chip);        //释放nand-chip结构体的内存
140 }
141
142 module_init(tiny_nand_init);
143 module_exit(tiny_nand_exit);
144
145 MODULE_LICENSE("GPL");

nand1.c

三、【高级】增加块设备分区结构体

andFlash还有一个分区表结构体,mtd_partition,这个是在arch/arm/plat-s3c24XX/common-smdk.c中定义的。


static struct mtd_partition tiny_nand_part[] = {

[0] = {

.name    = "bootloader",

.size    = SZ_4M,

.offset    = 0,

},

[1] = {

.name    = "kernel",

.size    = SZ_8M,

.offset    = MTDPART_OFS_APPEND,

},

[2] = {

.name    = "root",

.size    = MTDPART_SIZ_FULL,

.offset    = MTDPART_OFS_APPEND,

},

};

记录了当前的nand flash有几个分区,每个分区的名字,大小,偏移量是多少

系统就是依靠这些分区表找到各个文件系统的

这些分区表nand中的文件系统没有必然关系,分区表只是把flash分成不同的部分

如果自己编写一个nandflash驱动,只需要填充这三个结构体:

Mtd_info nand_chip mtd_partition

并实现对物理设备的控制,上层的驱动控制已由mtd做好了,不需要关心

然后使用

add_mtd_partitions(tiny_nand_mtd, tiny_nand_part, 3);

添加分区信息。

自然在exit函数中就要del_mtd_partitions(tiny_nand_mtd); //删除分区

附驱动源程序2见后

  1 #include <linux/module.h>
  2 #include <linux/types.h>
  3 #include <linux/init.h>
  4 #include <linux/kernel.h>
  5 #include <linux/string.h>
  6 #include <linux/ioport.h>
  7 #include <linux/platform_device.h>
  8 #include <linux/delay.h>
  9 #include <linux/err.h>
 10 #include <linux/slab.h>
 11 #include <linux/clk.h>
 12 #include <linux/cpufreq.h>
 13
 14 #include <linux/mtd/mtd.h>
 15 #include <linux/mtd/nand.h>
 16 #include <linux/mtd/nand_ecc.h>
 17 #include <linux/mtd/partitions.h>
 18
 19 #include <asm/io.h>
 20
 21 #include <plat/regs-nand.h>
 22 #include <plat/nand.h>
 23
 24 static unsigned long *clk_gate_ip1;
 25 static unsigned long *clk_gate_block;
 26 static unsigned long *mp0_3con;
 27
 28 static struct mtd_partition tiny_nand_part[] = {
 29     [0] = {
 30         .name    = "bootloader",
 31         .size    = SZ_4M,
 32         .offset    = 0,
 33     },
 34     [1] = {
 35         .name    = "kernel",
 36         .size    = SZ_8M,
 37         .offset    = MTDPART_OFS_APPEND,
 38     },
 39     [2] = {
 40         .name    = "root",
 41         .size    = MTDPART_SIZ_FULL,
 42         .offset    = MTDPART_OFS_APPEND,
 43     },
 44 };
 45
 46 struct nand_regs {
 47     unsigned long nfconf;
 48     unsigned long nfcont;
 49     unsigned long nfcmmd;
 50     unsigned long nfaddr;
 51     unsigned long nfdata;
 52     unsigned long nfmeccd0;
 53     unsigned long nfmeccd1;
 54     unsigned long nfseccd;
 55     unsigned long nfsblk;
 56     unsigned long nfeblk;
 57     unsigned long nfstat;
 58     unsigned long nfeccerr0;
 59     unsigned long nfeccerr1;
 60 };
 61
 62 static struct nand_regs *nand_regs;
 63 static struct nand_chip *tiny_nand_chip;
 64 static struct mtd_info *tiny_nand_mtd;
 65
 66 static void tiny_nand_select_chip(struct mtd_info *mtd, int chipnr)
 67 {
 68     if(chipnr == -1)
 69     {
 70         /*取消选择*/
 71         nand_regs->nfcont |= (1<<1);
 72     }
 73     else
 74     {
 75         /*选中芯片*/
 76         nand_regs->nfcont &= ~(1<<1);
 77     }
 78 }
 79
 80 static void tiny_nand_cmd_ctrl(struct mtd_info *mtd, int dat,
 81                 unsigned int ctrl)
 82 {
 83
 84     if (ctrl & NAND_CLE)
 85     {
 86         /*发命令*/
 87         nand_regs->nfcmmd = dat;
 88     }
 89     else
 90     {
 91         /*发地址*/
 92         nand_regs->nfaddr = dat;
 93     }
 94 }
 95
 96 static int tiny_nand_dev_ready(struct mtd_info *mtd)
 97 {
 98     /*等待命令的操作完成*/
 99     return (nand_regs->nfstat & (1<<0));
100 }
101
102 static int tiny_nand_init(void)
103 {
104     /*1.分配一个nand_chip结构体*/
105     tiny_nand_chip = kzalloc(sizeof(struct nand_chip),GFP_KERNEL);
106     nand_regs = ioremap(0xB0E00000,sizeof(struct nand_regs));
107     mp0_3con         = ioremap(0xE0200320,4);
108     clk_gate_ip1     = ioremap(0xE0100464,4);
109     clk_gate_block = ioremap(0xE0100480,4);
110
111     /*2.设置*/
112     /*
113      * 初始化nand_chip结构体中的函数指针
114      * 提供选中芯片,发命令,发地址,读数据,写数据,等待等操作
115      */
116     tiny_nand_chip->select_chip    = tiny_nand_select_chip;
117     tiny_nand_chip->cmd_ctrl        = tiny_nand_cmd_ctrl;
118     tiny_nand_chip->IO_ADDR_R   = &nand_regs->nfdata;
119     tiny_nand_chip->IO_ADDR_W  = &nand_regs->nfdata;
120     tiny_nand_chip->dev_ready     = tiny_nand_dev_ready;
121     tiny_nand_chip->ecc.mode      = NAND_ECC_SOFT;
122     //tiny_nand_chip->ecc.mode      = NAND_ECC_NONE;
123
124     /*3.硬件相关*/
125     /*使能时钟*/
126     *clk_gate_ip1     = 0xffffffff;
127     *clk_gate_block = 0xffffffff;
128
129     /* 设置相应GPIO管脚用于Nand */
130     *mp0_3con = 0x22222222;
131
132     /* 设置时序 */
133 #define TWRPH1    1
134 #define TWRPH0    1
135 #define TACLS        1
136     nand_regs->nfconf |= (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4);
137
138     /*
139      * AddrCycle[1]:1 = 发送地址需要5个周期
140      */
141     nand_regs->nfconf |= 1<<1;
142
143     /*
144      * MODE[0]:1     = 使能Nand Flash控制器
145      * Reg_nCE0[1]:1 = 取消片选
146      */
147     nand_regs->nfcont |= (1<<1)|(1<<0);
148
149     /*4.使用*/
150     tiny_nand_mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
151     tiny_nand_mtd->owner = THIS_MODULE;
152     tiny_nand_mtd->priv = tiny_nand_chip;
153
154     nand_scan(tiny_nand_mtd, 1);
155
156     /*5.添加分区*/
157     add_mtd_partitions(tiny_nand_mtd, tiny_nand_part, 3);
158
159     return 0;
160 }
161
162 static void tiny_nand_exit(void)
163 {
164     del_mtd_partitions(tiny_nand_mtd);
165     kfree(tiny_nand_mtd);
166     iounmap(nand_regs);
167     kfree(tiny_nand_chip);
168 }
169
170 module_init(tiny_nand_init);
171 module_exit(tiny_nand_exit);
172
173 MODULE_LICENSE("GPL");

nand2.c

四、NandFlash控制器

1.管脚配置

D[7:0]: DATA0-7 数据/命令/地址/的输入/输出口(与数据总线共享)

CLE : GPA17 命令锁存使能 (输出)

ALE : GPA18 地址锁存使能(输出)

nFCE : GPA22 NAND Flash 片选使能(输出)

nFRE : GPA20 NAND Flash 读使能 (输出)

nFWE : GPA19 NAND Flash 写使能 (输出)

R/nB : GPA21 NAND Flash 准备好/繁忙(输入)

2.相关寄存器:

NFCONF NandFlash控制寄存器

[15]NandFlash控制器使能/禁止 0 = 禁止 1 = 使能

[14:13]保留

[12]初始化ECC解码器/编码器 0 = 不初始化 1 = 初始化

[11]芯片使能 nFCE控制 0 = 使能 1 = 禁止

[10:8]TACLS 持续时间 = HCLK*(TACLS+1)

[6:4] TWRPH0

[2:0] TWRPH1

NFCMD 命令设置寄存器    [7:0] 命令值

NFADDR 地址设置寄存器    [7:0] 存储器地址

NFDATA 数据寄存器            [7:0] 存放数据

NFSTAT 状态寄存器            [0] 0 = 存储器忙 1 = 存储器准备好

NFECC ECC寄存器

[23:16]ECC校验码2

[15:8] ECC校验码1

[8:0] ECC校验码0

3.写操作:

写入操作以页为单位。写入必须在擦除之后,否则写入将出错。

页写入周期中包括以下步骤:

写入串行数据输入指令(80h)。然后写入4个字节的地址,最后串行写入数据(528Byte)。串行写入的数据最多为528byte。

串行数据写入完成后,需要写入"页写入确认"指令10h,这条指令将初始化器件内部写入操作。

10h写入之后,nand flash的内部写控制器将自动执行内部写入和校验中必要的算法和时序,

系统可以通过检测R/B的输出,或读状态寄存器的状态位(I/O 6)来判断内部写入是否结束

4.擦除操作:

擦除操作时以块(16K Byte)为单位进行的

擦除的启动指令为60h,随后的3个时钟周期是块地址。其中只有A14到A25是有效的,而A9到A13是可以忽略的。

块地址之后是擦除确认指令D0h,用来开始内部的擦除操作。

器件检测到擦除确认命令后,在/WE的上升沿启动内部写控制器,开始执行擦除和擦除校验。内部擦除操作完成后,应该检测写状态位(I/O 0),从而了解擦除操作是否成功完成。

5.读操作有两种读模式:

读方式1用于读正常数据;

读方式2用于读附加数据

在初始上电时,器件进入缺省的"读方式1模式"。在这一模式下,页读取操作通过将00h指令写入指令寄存器,接着写入3个地址(一个列地址和2个行地址)来启动。一旦页读指令被器件锁存,下面的页操作就不需要再重复写入指令了。

写入指令和地址后,处理器可以通过对信号线R//B的分析来判断该才作是否完成。

外部控制器可以再以50ns为周期的连续/RE脉冲信号的控制下,从I/O口依次读出数据

备用区域的从512到527地址的数据,可以通过读方式2指令进行指令进行读取(命令为50h)。地址A0~A3设置了备用区域的起始地址,A4~A7被忽略掉

时序要求:

写地址、数据、命令时,nCE、nWE信号必须为低电平,它们在nWE信号的上升沿被锁存。命令锁存使能信号CLE和地址锁存信号ALE用来区分I/O引脚上传输的是命令还是地址。

寻址方式:

NAND Flash的寻址方式和NAND Flash的memory组织方式紧密相关。NAND Flash的数据以bit的方式保存在memory cell,一个cell中只能存储一个bit。这些cell以8个或者16个为单位,连成bit line,形成byte(x8)/word(x16),这就是NAND的数据宽度。

这些Line会再组成Page,典型情况下:通常是528Byte/page或者264Word/page。然后,每32个page形成一个Block,Sizeof(block)=16.5kByte。其中528Byte = 512Byte+16Byte,前512Byte为数据区,后16Byte存放数据校验码等,因此习惯上人们称1page有512个字节,每个Block有16Kbytes;

现在在一些大容量的FLASH存贮设备中也采用以下配置:2112 Byte /page 或 1056 Word/page;64page/Block;Sizeof(block) = 132kByte;同上:2112 = 2048 +64,人们习惯称一页含2k个字节,一个Block含有64个页,容量为128KB;

Block是NAND Flash中最大的操作单元,擦除可以按照block或page为单位完成,而编程/读取是按照page为单位完成的

所以,按照这样的组织方式可以形成所谓的三类地址:

-Block Address 块地址

-Page Address 页地址

-Column Address 列地址

首先,必须清楚一点,对于NAND Flash来讲,地址和命令只能在I/O[7:0]上传递,数据宽度可以是8位或者16位,但是,对于x16的NAND Device,I/O[15:8]只用于传递数据。

清楚了这一点,我们就可以开始分析NAND Flash的寻址方式了。

以528Byte/page 总容量64M Byte+512kbyte的NAND器件为例:

因为

1page=528byte=512byte(Main Area)+16byte(Spare Area)

1block=32page = 16kbyte

64Mbyte = 4096 Block

用户数据保存在main area中。

512byte需要9bit来表示,对于528byte系列的NAND,这512byte被分成1st half和2nd half,各自的访问由所谓的pointer operation命令来选择,也就是选择了bit8的高低。因此A8就是halfpage pointer,A[7:0]就是所谓的column address。

32个page需要5bit来表示,占用A[13:9],即该page在块内的相对地址。

Block的地址是由A14以上的bit来表示,例如64MB的NAND,共4096block,因此,需要12个bit来表示,即A[25:14],如果是1Gbit的528byte/page的NAND Flash,共8192个block,则block address用A[30:14]表示。

NAND Flash的地址表示为:

Block Address | Page Address in block | half page pointer | Column Address

地址传送顺序是Column Address , Page Address , Block Address。

例如一个地址:0x00aa55aa

0000 0000 1010 1010 0101 0101 1010 1010

由于地址只能在I/O[7:0]上传递,因此,必须采用移位的方式进行。

例如,对于64MBx8的NAND flash,地址范围是0~0x3FF_FFFF,只要是这个范围内的数值表示的地址都是有效的。

以NAND_ADDR为例:

第1步是传递column address,就是NAND_ADDR[7:0],不需移位即可传递到I/O[7:0]上, 而halfpage pointer即bit8是由操作指令决定的,即指令决定在哪个halfpage上进行读写,而真正的bit8的值是don‘t care的。

第2步就是将NAND_ADDR右移9位,将NAND_ADDR[16:9]传到I/O[7:0]上;

第3步将NAND_ADDR[24:17]放到I/O上;

第4步需要将NAND_ADDR[25]放到I/O上;

因此,整个地址传递过程需要4步才能完成,即4-step addressing。

如果NAND Flash的容量是32MB以下,那么,block adress最高位只到bit24,因此寻址只需要3步。

以上部分知识点摘自: http://blog.chinaunix.net/uid-22848040-id-1767599.html

附驱动源程序1:

  1 #include <linux/module.h>
  2 #include <linux/types.h>
  3 #include <linux/init.h>
  4 #include <linux/kernel.h>
  5 #include <linux/string.h>
  6 #include <linux/ioport.h>
  7 #include <linux/platform_device.h>
  8 #include <linux/delay.h>
  9 #include <linux/err.h>
 10 #include <linux/slab.h>
 11 #include <linux/clk.h>
 12 #include <linux/cpufreq.h>
 13
 14 #include <linux/mtd/mtd.h>
 15 #include <linux/mtd/nand.h>
 16 #include <linux/mtd/nand_ecc.h>
 17 #include <linux/mtd/partitions.h>
 18
 19 #include <asm/io.h>
 20
 21 #include <plat/regs-nand.h>
 22 #include <plat/nand.h>
 23 //nand falsh寄存器列表结构体
 24 struct nand_regs {
 25     unsigned long nfconf;
 26     unsigned long nfcont;
 27     unsigned long nfcmmd;
 28     unsigned long nfaddr;
 29     unsigned long nfdata;
 30     unsigned long nfmeccd0;
 31     unsigned long nfmeccd1;
 32     unsigned long nfseccd;
 33     unsigned long nfsblk;
 34     unsigned long nfeblk;
 35     unsigned long nfstat;
 36     unsigned long nfeccerr0;
 37     unsigned long nfeccerr1;
 38 };
 39
 40 static struct nand_regs *nand_regs;           //nand flash 结构体,主要是定义了芯片寄存器的地址
 41 static struct nand_chip *tiny_nand_chip;    //主要定义了一些读写打开等操作函数
 42 static struct mtd_info *tiny_nand_mtd         //描述了存储设备的基本信息和具体操作所需要的内核函数
 43
 44 //芯片选择函数
 45 static void tiny_nand_select_chip(struct mtd_info *mtd, int chipnr)
 46 {
 47     if(chipnr == -1)
 48     {
 49         /*取消选择  NFCONT[1]设为1*/
 50         nand_regs->nfcont |= (1<<1);
 51     }
 52     else
 53     {
 54         /*选中芯片  NFCONT[1]设为0*/
 55         nand_regs->nfcont &= ~(1<<1);
 56     }
 57 }
 58
 59 //命令控制,数据发送函数
 60 static void tiny_nand_cmd_ctrl(struct mtd_info *mtd, int dat,
 61                 unsigned int ctrl)
 62 {
 63
 64     if (ctrl & NAND_CLE)
 65     {
 66         /*发命令  NFCMMD = dat*/
 67         nand_regs->nfcmmd = dat;
 68     }
 69     else
 70     {
 71         /*发地址  NFADDR = dat*/
 72         nand_regs->nfaddr = dat;
 73     }
 74 }
 75
 76 static int tiny_nand_dev_ready(struct mtd_info *mtd, struct nand_chip *chip)
 77 {
 78     /*等待命令的操作完成*/
 79     return (nand_regs->nfstat & (1<<0));
 80 }
 81
 82 static int tiny_nand_init(void)
 83 {
 84     struct clk *nand_clk;
 85     /*1.分配一个nand_chip结构体,主要定义了一些操作函数*/
 86     tiny_nand_chip = kzalloc(sizeof(struct nand_chip),GFP_KERNEL);     //分配nand_chip结构体内存
 87     nand_regs = ioremap(0xB0E00000,sizeof(struct nand_regs));        //映射nand_chip结构体地址
 88
 89     /*2.设置*/
 90     /*
 91      * 初始化nand_chip结构体中的函数指针,设置nand_chip 是给nand_scan函数使用的,
 92      * 如果不知道咋么设置先看nand_scan怎么使用
 93      * 提供选中芯片,发命令,发地址,读数据,写数据,等待等操作
 94      */
 95     tiny_nand_chip->select_chip    = tiny_nand_select_chip; //nand片选控制函数
 96     tiny_nand_chip->cmd_ctrl        = tiny_nand_cmd_ctrl;    //命令控制函数,包括数据和地址命令的发送
 97     tiny_nand_chip->IO_ADDR_R   = &nand_regs->nfdata;        //nandflash的读寄存器
 98     tiny_nand_chip->IO_ADDR_W  = &nand_regs->nfdata;        //nandflash的写寄存器
 99     tiny_nand_chip->dev_ready     = tiny_nand_dev_ready;    //nand准备完毕,可以开始读写, GPIO_RDY        8
100     tiny_nand_chip->ecc.mode      = NAND_ECC_SOFT;            ////ecc的校验模式(软件,硬件)
101     /*3.硬件相关*/
102     /*使能时钟*/
103     nand_clk = clk_get(NULL, "nand");        //从内核中找到nand的时钟信息,通过名字匹配
104     clk_enable(nand_clk);                    //时能nandflash的时钟
105
106     /*
107      * AddrCycle[1]:1 = 发送地址需要5个周期
108      */
109     nand_regs->nfconf |= 1<<1;        //取消片选
110     //HCLK = 100MHz
111     //TACLS : 发出CLE/ALE之后多长时间才发出nWE信号,
112     //    从NAND手册克制CLE/ALE与nWE可以同时faculty,所以TACLS = 0
113     //TWRPH0:nWE的脉冲宽度,HCLK x(TWRPH0 + 1),
114     //    从NAND手册克制它要>=12ns,    所以TWRPH0 >= 1
115     //TWRPH1: nWE变为高电平后多长时间CLE/ALE才能变为低电平,
116     //    从NAND手册值要>=5ns,        所以TWRPH1 >= 0
117 #define TWRPH1       0    //1
118 #define TWRPH0       1
119 #define TACLS        0    //1
120     nand_regs->nfconf |= (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4); //设置脉冲信号
121     /*
122      * MODE[0]:1     = 使能Nand Flash控制器
123      * Reg_nCE0[1]:1 = 取消片选
124      */
125     nand_regs->nfcont |= (1<<1)|(1<<0);    //时能nandflash控制器,取消片选
126     /*4.使用*/
127     tiny_nand_mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); //申请mtd_info结构体内存
128     tiny_nand_mtd->owner = THIS_MODULE;
129     tiny_nand_mtd->priv = tiny_nand_chip;        //设置设备私有数据指针,绑定前面的nand_chip结构体
130
131     nand_scan(tiny_nand_mtd, 1);    //扫描识别nand flash ,构造mtd_info结构体
132
133 }
134
135 static void tiny_nand_exit(void)
136 {
137     kfree(tiny_nand_mtd);        //释放mtd结构体的内存
138     iounmap(nand_regs);            //取消地址映射
139     kfree(tiny_nand_chip);        //释放nand-chip结构体的内存
140 }
141
142 module_init(tiny_nand_init);
143 module_exit(tiny_nand_exit);
144
145 MODULE_LICENSE("GPL");

nand1.c

附驱动源程序2:

  1 #include <linux/module.h>
  2 #include <linux/types.h>
  3 #include <linux/init.h>
  4 #include <linux/kernel.h>
  5 #include <linux/string.h>
  6 #include <linux/ioport.h>
  7 #include <linux/platform_device.h>
  8 #include <linux/delay.h>
  9 #include <linux/err.h>
 10 #include <linux/slab.h>
 11 #include <linux/clk.h>
 12 #include <linux/cpufreq.h>
 13
 14 #include <linux/mtd/mtd.h>
 15 #include <linux/mtd/nand.h>
 16 #include <linux/mtd/nand_ecc.h>
 17 #include <linux/mtd/partitions.h>
 18
 19 #include <asm/io.h>
 20
 21 #include <plat/regs-nand.h>
 22 #include <plat/nand.h>
 23
 24 static unsigned long *clk_gate_ip1;
 25 static unsigned long *clk_gate_block;
 26 static unsigned long *mp0_3con;
 27
 28 static struct mtd_partition tiny_nand_part[] = {
 29     [0] = {
 30         .name    = "bootloader",
 31         .size    = SZ_4M,
 32         .offset    = 0,
 33     },
 34     [1] = {
 35         .name    = "kernel",
 36         .size    = SZ_8M,
 37         .offset    = MTDPART_OFS_APPEND,
 38     },
 39     [2] = {
 40         .name    = "root",
 41         .size    = MTDPART_SIZ_FULL,
 42         .offset    = MTDPART_OFS_APPEND,
 43     },
 44 };
 45
 46 struct nand_regs {
 47     unsigned long nfconf;
 48     unsigned long nfcont;
 49     unsigned long nfcmmd;
 50     unsigned long nfaddr;
 51     unsigned long nfdata;
 52     unsigned long nfmeccd0;
 53     unsigned long nfmeccd1;
 54     unsigned long nfseccd;
 55     unsigned long nfsblk;
 56     unsigned long nfeblk;
 57     unsigned long nfstat;
 58     unsigned long nfeccerr0;
 59     unsigned long nfeccerr1;
 60 };
 61
 62 static struct nand_regs *nand_regs;
 63 static struct nand_chip *tiny_nand_chip;
 64 static struct mtd_info *tiny_nand_mtd;
 65
 66 static void tiny_nand_select_chip(struct mtd_info *mtd, int chipnr)
 67 {
 68     if(chipnr == -1)
 69     {
 70         /*取消选择*/
 71         nand_regs->nfcont |= (1<<1);
 72     }
 73     else
 74     {
 75         /*选中芯片*/
 76         nand_regs->nfcont &= ~(1<<1);
 77     }
 78 }
 79
 80 static void tiny_nand_cmd_ctrl(struct mtd_info *mtd, int dat,
 81                 unsigned int ctrl)
 82 {
 83
 84     if (ctrl & NAND_CLE)
 85     {
 86         /*发命令*/
 87         nand_regs->nfcmmd = dat;
 88     }
 89     else
 90     {
 91         /*发地址*/
 92         nand_regs->nfaddr = dat;
 93     }
 94 }
 95
 96 static int tiny_nand_dev_ready(struct mtd_info *mtd)
 97 {
 98     /*等待命令的操作完成*/
 99     return (nand_regs->nfstat & (1<<0));
100 }
101
102 static int tiny_nand_init(void)
103 {
104     /*1.分配一个nand_chip结构体*/
105     tiny_nand_chip = kzalloc(sizeof(struct nand_chip),GFP_KERNEL);
106     nand_regs = ioremap(0xB0E00000,sizeof(struct nand_regs));
107     mp0_3con         = ioremap(0xE0200320,4);
108     clk_gate_ip1     = ioremap(0xE0100464,4);
109     clk_gate_block = ioremap(0xE0100480,4);
110
111     /*2.设置*/
112     /*
113      * 初始化nand_chip结构体中的函数指针
114      * 提供选中芯片,发命令,发地址,读数据,写数据,等待等操作
115      */
116     tiny_nand_chip->select_chip    = tiny_nand_select_chip;
117     tiny_nand_chip->cmd_ctrl        = tiny_nand_cmd_ctrl;
118     tiny_nand_chip->IO_ADDR_R   = &nand_regs->nfdata;
119     tiny_nand_chip->IO_ADDR_W  = &nand_regs->nfdata;
120     tiny_nand_chip->dev_ready     = tiny_nand_dev_ready;
121     tiny_nand_chip->ecc.mode      = NAND_ECC_SOFT;
122     //tiny_nand_chip->ecc.mode      = NAND_ECC_NONE;
123
124     /*3.硬件相关*/
125     /*使能时钟*/
126     *clk_gate_ip1     = 0xffffffff;
127     *clk_gate_block = 0xffffffff;
128
129     /* 设置相应GPIO管脚用于Nand */
130     *mp0_3con = 0x22222222;
131
132     /* 设置时序 */
133 #define TWRPH1    1
134 #define TWRPH0    1
135 #define TACLS        1
136     nand_regs->nfconf |= (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4);
137
138     /*
139      * AddrCycle[1]:1 = 发送地址需要5个周期
140      */
141     nand_regs->nfconf |= 1<<1;
142
143     /*
144      * MODE[0]:1     = 使能Nand Flash控制器
145      * Reg_nCE0[1]:1 = 取消片选
146      */
147     nand_regs->nfcont |= (1<<1)|(1<<0);
148
149     /*4.使用*/
150     tiny_nand_mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
151     tiny_nand_mtd->owner = THIS_MODULE;
152     tiny_nand_mtd->priv = tiny_nand_chip;
153
154     nand_scan(tiny_nand_mtd, 1);
155
156     /*5.添加分区*/
157     add_mtd_partitions(tiny_nand_mtd, tiny_nand_part, 3);
158
159     return 0;
160 }
161
162 static void tiny_nand_exit(void)
163 {
164     del_mtd_partitions(tiny_nand_mtd);
165     kfree(tiny_nand_mtd);
166     iounmap(nand_regs);
167     kfree(tiny_nand_chip);
168 }
169
170 module_init(tiny_nand_init);
171 module_exit(tiny_nand_exit);
172
173 MODULE_LICENSE("GPL");

nand2.c

时间: 2024-10-11 11:51:17

20150311 NandFlash驱动分析的相关文章

linux串口驱动分析

linux串口驱动分析 硬件资源及描写叙述 s3c2440A 通用异步接收器和发送器(UART)提供了三个独立的异步串行 I/O(SIO)port,每一个port都能够在中断模式或 DMA 模式下操作.UART 使用系统时钟能够支持最高 115.2Kbps 的波特率.每一个 UART 通道对于接收器和发送器包含了 2 个 64 位的 FIFO. 寄存器 名称 地址 在linux中的描写叙述 (2410 和 2440 处理器对内存地址映射关系同样) UART 线性控制寄存器(ULCONn) ULC

8.NandFlash原理分析

8.NandFlash原理分析 该节里主要是将NandFlash有关的知识,首先是NandFlash的角色.分类和访问方式. 角色分析:在个人的pc机中,使用硬盘来存储操作系统.数据等信息.在嵌入式领域,拥有硬盘功能的叫NandFlash.所以NandFlash就是存储信息的. NandFlash分类: SLC原理略图: MLC原理略图: 从上面可以看到MLC的存储密度比SLC的存储密度大两倍,他们两者的信息比较: 接下来是访问方式: 编址方式. 地址结构. 信号引脚. 1.编址方式: 首先看内

atheros wifi 驱动分析

Ar6003 驱动文档摘要 1.  wmi : wireless module interface //无线模块结构 2.  bmi : bootloader message interface 3.  htc : host target communications 4.  wps:wifi protected setup 5.  CS:connection services module 6.  STA:station 7.  AP:access point Wireless applica

STM32-移植FATFS的NANDFLASH驱动

一,建立工程FATFS源码 1,在http://elm-chan.org/fsw/ff/00index_e.html上下载ff007c.zip,并把ff007c.zip里面的 src文件夹复制到D:\works\EK-STM3210E-UCOSII下,并改名为Fatfs: 2,在IDE工程中右击选择“Add Group”建立“FATFS”文件组,并在“FATFS”上右击选择“Add Files”添加 D:\works\EK-STM3210E-UCOSII\Fatfs下的C文件: 3,把D:\wo

蓝牙驱动分析 linux

蓝牙驱动分析 这个驱动分析的是OK6410开发板自带的内核版本是linux3.0.1,所支持的wifi和蓝牙一体芯片是marvell的8688和8787.根据开发板的设计,芯片与主机之间是通过sdio协议接口通信的,所以驱动也是通过sdio的方式写的. 个人分析驱动的过程是从插入设备驱动的动作开始的. 首先每次插入设备和拔出设备驱动都会通过终端打印相应的信息,判断在sd卡槽中肯定是触发中断的,通过看硬件原理图和数据手册中的SDMMC控制器可知用于mmc的中断号分别为56和57,回到代码中.在内核

[国嵌攻略][140][触摸屏驱动分析]

触摸屏驱动分析 初始化 1.使能ADC时钟 2.将物理地址转化为虚拟地址 3.让触摸屏进入等待中断模式 4.分配输入设备结构 5.设置可能上报的事件类型和按键类型 6.为TC和ADC中断注册处理函数 7.注册输入型设备 按下处理 1.判断按下或弹起 2.如果是按下情况,那么启动XY坐标的AD转换 3.进行4次ADC转换,获取4次XY坐标值 4.计算4次采集的平均值,并上报给内核

【linux驱动分析】之dm9000驱动分析(三):sk_buff结构分析

[linux驱动分析]之dm9000驱动分析(一):dm9000原理及硬件分析 [linux驱动分析]之dm9000驱动分析(二):定义在板文件里的资源和设备以及几个宏 [linux驱动分析]之dm9000驱动分析(四):net_device结构体 [linux驱动分析]之dm9000驱动分析(五):另外几个重要的结构体 [linux驱动分析]之dm9000驱动分析(六):dm9000_init和dm9000_probe的实现 [linux驱动分析]之dm9000驱动分析(七):dm9000的卸

linux input设备驱动分析

linux input设备驱动分析 工作机制 输入设备工作机制: 输入动作–>产生中断–>CPU通过总线或者IO读取数据到缓冲区 构架层次 app //-------------------- input_event_driver //-------------------- input_core //-------------------- input_device_driver //-------------------- hardware 数据结构 输入设备对象 struct input

S3C6410 LCD驱动分析(转)

一. 理论分析1. 几个概念:FIMC :    Fully Interactive Mobile Camera (完全交互式移动摄像机)FIMD:     Fully Interactive Mobile Display (完全交互式移动显示设备)2. 设置VCLK在VIDCON0中bit[3:2]-->Select the Video Clock source =00 --> HCLK=133MHZbit[13:6] --> CLKVAL_F = 13  (这个值是在驱动中计算出来的