NandFlash驱动分析

NandFlash驱动分析（一）

2010-03-16 19:05

内核启动信息，NAND 部分：

S3C24XX NAND Driver, (c) 2004 Simtec Electronics

s3c2440-nand s3c2440-nand: Tacls=2, 20ns Twrph0=3 30ns, Twrph1=2 20ns

NAND device: Manufacturer ID: 0xec, Chip ID: 0x76 (Samsung NAND 64MiB 3,3V 8-bit)

Scanning device for bad blocks

Creating 3 MTD partitions on "NAND 64MiB 3,3V 8-bit":

0x00000000-0x00040000 : "boot"

0x0004c000-0x0024c000 : "kernel"

0x0024c000-0x03ffc000 : "yaffs2"

第一行，在driver/mtd/nand/s3c2410.c 中第910 行，s3c2410_nand_init 函数：

printk("S3C24XX NAND Driver, (c) 2004 Simtec Electronics/n");

行二行，同一文件，第212 行，s3c2410_nand_inithw 函数：

dev_info(info->device, "Tacls=%d, %dns Twrph0=%d %dns, Twrph1=%d %dns/n", tacls, to_ns(tacls, clkrate), twrph0, to_ns(twrph0, clkrate), twrph1, to_ns(twrph1, clkrate));

第三行，在driver/mtd/nand/nand_base.c 中第2346 行，

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, type->name);

第四行，在driver/mtd/nand/nand_bbt.c 中第380 行，creat_bbt 函数：

Printk(KERN INFO " Scanning device for bad blocks /n");

第五行，在driver/mtd/mtdpart.c 中第340 行，add_mtd_partitions 函数：

printk (KERN_NOTICE "Creating %d MTD partitions on /"%s/":/n", nbparts, master->name);

下面三行，是flash 分区表，也在mtdpart.c 同一函数中，第430 行：

printk (KERN_NOTICE "0x%08x-0x%08x : /"%s/"/n", slave->offset, slave->offset + slave->mtd.size, slave->mtd.name);

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 ）的统一组织方式。

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 芯片的结构

下面看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具体操作。

 

 

 

 

======================================================

 

 

 

 

NandFlash驱动分析（二）

2010-03-16 19:08

跟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 ，则该文件也不需理会。

我们需要关心的是/nand/s3c2410, 这个文件实现的是s3c2410/2440nandflash 控制器最基本的硬件操作，读写擦除操作由上层函数完成。

s3c2410.c 分析：

首先看一下要用到的结构体的注册：

struct s3c2410_nand_mtd {

    struct mtd_info      mtd;   //mtd_info 的结构体

    struct nand_chip     chip; //nand_chip 的结构体

    struct s3c2410_nand_set     *set;

    struct s3c2410_nand_info    *info;

    int           scan_res;

};

enum s3c_cpu_type { // 用来枚举CPU 类型

    TYPE_S3C2410,

    TYPE_S3C2412,

    TYPE_S3C2440,

};

struct s3c2410_nand_info {

    /* mtd info */

    struct nand_hw_control      controller;

    struct s3c2410_nand_mtd     *mtds;

    struct s3c2410_platform_nand    *platform;

    /* device info */

    struct device        *device;

    struct resource          *area;

    struct clk        *clk;

    void __iomem         *regs;

    void __iomem         *sel_reg;

    int           sel_bit;

    int           mtd_count;

    unsigned long        save_nfconf;

    enum s3c_cpu_type    cpu_type;

};

设备的注册：

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

}

platform_driver_register 向内核注册设备，同时支持这三种CPU 。

&s3c2440_nand_driver 是一个platform_driver 类型的结构体：

static struct platform_driver s3c2440_nand_driver = {

    .probe     = s3c2440_nand_probe,

    .remove   = s3c2410_nand_remove,

    .suspend   = s3c24xx_nand_suspend,

    .resume    = s3c24xx_nand_resume,

    .driver    = {

       .name = "s3c2440-nand",

       .owner = THIS_MODULE,

    },

};

最主要的函数就是s3c2440_nand_probe ，（调用s3c24XX_nand_probe ）, 完成对nand 设备的探测，

static int s3c24xx_nand_probe(struct platform_device *pdev,

                 enum s3c_cpu_type cpu_type)

{

       /* 主要完成一些硬件的初始化，其中调用函数：*/

       s3c2410_nand_init_chip (info, nmtd, sets);

       /*init_chip 结束后，调用nand_scan 完成对flash 的探测及mtd_info 读写函数的赋值*/

nmtd->scan_res = nand_scan (&nmtd->mtd, (sets) ? sets->nr_chips : 1);

       if (nmtd->scan_res == 0) {

           s3c2410_nand_add_partition (info, nmtd, sets);

       }

}

Nand_scan 是在初始化nand 的时候对nand 进行的一步非常好重要的操作，在nand_scan 中会对我们所写的关于特定芯片的读写函数重载到nand_chip 结构中去，并会将mtd_info 结构体中的函数用nand 的函数来重载，实现了mtd 到底层驱动的联系。

并且在nand_scan 函数中会通过读取nand 芯片的设备号和厂家号自动在芯片列表中寻找相应的型号和参数，并将其注册进去。

static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,

                 struct s3c2410_nand_mtd *nmtd,

                 struct s3c2410_nand_set *set)

{

    struct nand_chip *chip = &nmtd->chip;

    void __iomem *regs = info->regs;

    /* 以下都是对chip 赋值，对应nand_chip 中的函数*/

    chip->write_buf    = s3c2410_nand_write_buf; // 写buf

    chip->read_buf     = s3c2410_nand_read_buf;   // 读buf

    chip->select_chip = s3c2410_nand_select_chip;// 片选

    chip->chip_delay   = 50;

    chip->priv    = nmtd;

    chip->options    = 0;

    chip->controller   = &info->controller; // ？？

    switch (info->cpu_type) {

    case TYPE_S3C2440:

       chip->IO_ADDR_W = regs + S3C2440_NFDATA; // 数据寄存器

       info->sel_reg   = regs + S3C2440_NFCONT; // 控制寄存器

       info->sel_bit = S3C2440_NFCONT_nFCE;

       chip->cmd_ctrl = s3c2440_nand_hwcontrol; // 硬件控制

       chip->dev_ready = s3c2440_nand_devready; // 设备就绪

       chip->read_buf = s3c2440_nand_read_buf; // 读buf

       chip->write_buf   = s3c2440_nand_write_buf;// 写buf

       break;

}

    chip->IO_ADDR_R = chip->IO_ADDR_W; // 读写寄存器都是同一个

    nmtd->info    = info;

    nmtd->mtd.priv       = chip; // 私有数据指针指向chip

    nmtd->mtd.owner    = THIS_MODULE;

    nmtd->set    = set;

    /* 后面是和ECC 校验有关的，省略*/

}

初始化后，实现对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

 

 

 

==========================================================

 

 

 

NandFlash驱动分析（三）

2010-03-16 19:10

注册nand 设备到MTD 原始设备层：（这个函数由probe 调用）

#ifdef CONFIG_MTD_PARTITIONS   // 如果定义了MTD 分区

static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,

                    struct s3c2410_nand_mtd *mtd,

                    struct s3c2410_nand_set *set)

{

    if (set == NULL)

       return add_mtd_device(&mtd->mtd);

    if (set->nr_partitions > 0 && set->partitions != NULL) {

       return add_mtd_partitions(&mtd->mtd, set->partitions, set->nr_partitions);

    }

    return add_mtd_device(&mtd->mtd);

}

#else

注册设备用这两个函数：

add_mtd_device // 如果nand 整体不分区，用这个，

// 该函数在mtdcore.c 中实现

add_mtd_partitions // 如果nand 是分区结构，用这个，

// 该函数在mtdpart.c 中实现

同样，注销设备也有两个函数：

del_mtd_device

del_mtd_partitions

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

static struct mtd_partition smdk_default_nand_part[] = {

    [0] = {

       .name = "boot",

       .size = 0x00040000,

       .offset    = 0,

    },

    [1] = {

       .name = "kernel",

       .offset = 0x0004C000,

       .size = 0x00200000,

    },

    [2] = {

       .name = "yaffs2",

       .offset = 0x0024C000,

       .size = 0x03DB0000,

    },

};

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

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

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

 

 

*******************very  good！******************

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

Mtd_info     nand_chip     mtd_partition

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

***********************************************

 

2410NandFlash 控制器

管脚配置

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 准备好/ 繁忙（输入）

相关寄存器：

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

写操作：

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

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

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

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

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

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

擦除操作：

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

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

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

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

读操作 有两种读模式：

读方式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 引脚上传输的是命令还是地址。

 

==========================================================

 

NandFlash驱动分析（四）

2010-03-16 19:12

寻址方式：

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 01 01 010 1 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 步。