Crifan Li

摘要

本文先解释了Nand Flash相关的一些名词，再从Flash硬件机制开始，介绍到Nand Flash的常见的物理特性，且深入介绍了Nand Flash的一些高级功能，然后开始介绍Linux下面和Nand Flash相关的软件架构MTD的相关知识，最后介绍了在Linux的MTD驱动框架下，如何实现Nand Flash的驱动。

	本文提供多种格式供：
	在线阅读 HTML HTMLs PDF CHM TXT RTF WEBHELP 下载（7zip压缩包） HTML HTMLs PDF CHM TXT RTF WEBHELP HTML版本的在线地址为： http://www.crifan.com/files/doc/docbook/linux_nand_driver/release/html/linux_nand_driver.html 有任何意见，建议，提交bug等，都欢迎去讨论组发帖讨论： http://www.crifan.com/bbs/categories/linux_nand_driver/

本文章遵从：署名-非商业性使用 2.5 *(CC BY-NC 2.5)

1.1.1. Non-Volatile Memory非易失性存储器

1.1.2. OTP一次性可编程存储器

1.1.3. NDA 保密协议

1.1.4. Datasheet数据手册和Specification规范

1.1.5. Nand Flash相关的一些名词解释

Nand Flash由于其物理特性，只有有限的擦写次数，超过那个次数，基本上就是坏了。在使用过程中，有些Nand Flash的block会出现被用坏了，当发现了，要及时将此block标注为坏块，不再使用。

于此相关的管理工作，属于Nand Flash的坏块管理的一部分工作。

Nand Flash的block的管理，还包括负载平衡。

正是由于Nand Flash的block，都是有一定寿命限制的，所以如果你每次都往同一个block擦除然后写入数据，那么那个block就很容易被用坏了，所以我们要去管理一下，将这么多次的对同一个block的操作，平均分布到其他一些block上面，使得在block的使用上，相对较平均，这样相对来说，可以更能充分利用Nand Flash。

关于wear-leveling这个词，再简单解释一下，wear就是穿（衣服）等，用（东西）导致磨损，而leveling就是使得均衡，所以放在一起就是，使得对于Nand Flash的那么多的block的使用磨损，相对均衡一些，以此延长Nand Flash的使用寿命或者说更加充分利用Nand Flash。

Nand Flash物理特性上使得其数据读写过程中会发生一定几率的错误，所以要有个对应的错误检测和纠正的机制，于是才有此ECC，用于数据错误的检测与纠正。Nand Flash的ECC，常见的算法有海明码和BCH，这类算法的实现，可以是软件也可以是硬件。不同系统，根据自己的需求，采用对应的软件或者是硬件。

相对来说，硬件实现这类ECC算法，肯定要比软件速度要快，但是多加了对应的硬件部分，所以成本相对要高些。如果系统对于性能要求不是很高，那么可以采用软件实现这类ECC算法，但是由于增加了数据读取和写入前后要做的数据错误检测和纠错，所以性能相对要降低一些，即Nand Flash的读取和写入速度相对会有所影响。

其中，Linux中的软件实现ECC算法，即NAND_ECC_SOFT模式，就是用的对应的海明码。

而对于目前常见的MLC的Nand Flash来说，由于容量比较大，动辄2GB，4GB，8GB等，常用BCH算法。BCH算法，相对来说，算法比较复杂。

笔者由于水平有限，目前仍未完全搞懂BCH算法的原理。

BCH算法，通常是由对应的Nand Flash的Controller中，包含对应的硬件BCH ECC模块，实现了BCH算法，而作为软件方面，需要在读取数据后，写入数据之前，分别操作对应BCH相关的寄存器，设置成BCH模式，然后读取对应的BCH状态寄存器，得知是否有错误，和生成的BCH校验码，用于写入。

其具体代码是如何操作这些寄存器的，由于是和具体的硬件，具体的nand flash的controller不同而不同，无法用同一的代码。如果你是nand flash驱动开发者，自然会得到对应的起nand flash的controller部分的datasheet，按照手册说明，去操作即可。

不过，额外说明一下的是，关于BCH算法，往往是要从专门的做软件算法的厂家购买的，但是Micron之前在网上放出一个免费版本的BCH算法。

想要此免费的BCH算法，可以在[18]找到下载地址

1.2.1. 什么是Flash

Flash的内部存储是MOSFET，里面有个悬浮门(Floating Gate)，是真正存储数据的单元。

在Flash之前，紫外线可擦除(uv-erasable)的EPROM，就已经采用了Floating Gate存储数据这一技术了。

图 1.1. 典型的Flash内存单元的物理结构

数据在Flash内存单元中是以电荷(electrical charge) 形式存储的。存储电荷的多少，取决于图中的外部门（external gate）所被施加的电压，其控制了是向存储单元中冲入电荷还是使其释放电荷。而数据的表示，以所存储的电荷的电压是否超过一个特定的阈值Vth来表示，因此，Flash的存储单元的默认值，不是0（其他常见的存储设备，比如硬盘灯，默认值为0），而是1，而如果将电荷释放掉，电压降低到一定程度，表述数字0。

1.2.2. 什么是Nand Flash

1. Nor的成本相对高，容量相对小，比如常见的只有128KB，256KB，1MB，2MB等等，优点是读写数据时候，不容易出错。所以在应用领域方面，Nor Flash比较适合应用于存储少量的代码。

2. Nand flash成本相对低，说白了就是便宜，缺点是使用中数据读写容易出错，所以一般都需要有对应的软件或者硬件的数据校验算法，统称为ECC。但优点是，相对来说容量比较大，现在常见的Nand Flash都是1GB，2GB，更大的8GB的都有了，相对来说，价格便宜，因此适合用来存储大量的数据。其在嵌入式系统中的作用，相当于PC上的硬盘，用于存储大量数据。

Nand Flash，按照硬件类型，可以分为

1.2.3. SLC和MLC的实现机制

单个存储单元，只存储一位数据，表示1或0。

就是上面介绍的，对于数据的表示，单个存储单元中内部所存储电荷的电压，和某个特定的阈值电压Vth，相比，如果大于此Vth值，就是表示1，反之，小于Vth，就表示0。

对于Nand Flash的数据的写入1，就是控制External Gate去充电，使得存储的电荷够多，超过阈值Vth，就表示1了。而对于写入0，就是将其放电，电荷减少到小于Vth，就表示0了。

关于为何Nand Flash不能从0变成1，我的理解是，物理上来说，是可以实现每一位的，从0变成1的，但是实际上，对于实际的物理实现，出于效率的考虑，如果对于，每一个存储单元都能单独控制，即，0变成1就是，对每一个存储单元单独去充电，所需要的硬件实现就很复杂和昂贵，同时，所进行对块擦除的操作，也就无法实现之前所说的的，Flash的速度，即一闪而过的速度了，也就失去了Flash的众多特性了。

与SLC相对应的，就是单个存储单元，可以存储多个位，比如2位，4位等。其实现机制，说起来比较简单，就是通过控制内部电荷的多少，分成多个阈值，通过控制里面的电荷多少，而达到我们所需要的存储成不同的数据。比如，假设输入电压是Vin＝4V（实际没有这样的电压，此处只是为了举例方便），那么，可以设计出2的2次方＝4个阈值， 1/4 的Vin＝1V，2/4的Vin＝2V，3/4的Vin＝3V，Vin＝4V，分别表示2位数据00，01，10，11，对于写入数据，就是充电，通过控制内部的电荷的多少，对应表示不同的数据。

对于读取，则是通过对应的内部的电流（与Vth成反比），然后通过一系列解码电路完成读取，解析出所存储的数据。这些具体的物理实现，都是有足够精确的设备和技术，才能实现精确的数据写入和读出的。

单个存储单元可以存储2位数据的，称作2的2次方＝4 Level Cell，而不是2 Level Cell，关于这点，之前看Nand flash的数据手册（datasheet）的时候，差点搞晕了。

同理，对于新出的单个存储单元可以存储4位数据的，称作 2的4次方＝16 Level Cell。

Nand Flash设计中，有个命令叫做Read ID，读取ID，意思是读取芯片的ID，就像大家的身份证一样，这里读取的ID中，是读取好几个字节，一般最少是4个，新的芯片，支持5个甚至更多，从这些字节中，可以解析出很多相关的信息，比如此Nand Flash内部是几个芯片（chip）所组成的，每个chip包含了几片（Plane），每一片中的页大小，块大小，等等。在这些信息中，其中有一个，就是识别此flash是SLC还是MLC。下面这个就是最常见的Nand Flash的datasheet中所规定的，第3个字节，3rd byte，所表示的信息，其中就有SLC/MLC的识别信息：

1.2.4. Nand Flash数据存储单元的整体架构

图 1.2. Nand Flash的结构图

公式 1.1. K9K8G08U0A的物理结构所组成的总容量

1.2.5. Nand Flash的物理存储单元的阵列组织结构

图 1.3. Nand Flash物理存储单元的阵列组织结构

一个Nand Flash（的chip，芯片）由很多个块（Block）组成，块的大小一般是128KB，256KB，512KB，此处是128KB。其他的小于128KB的，比如64KB，一般都是下面将要介绍到的small block的Nand Flash。

块Block，是Nand Flash的擦除操作的基本/最小单位。

每个块里面又包含了很多页（page）。每个页的大小，对于现在常见的Nand Flash多数是2KB，最新的Nand Flash的是4KB、8KB等，这类的页大小大于2KB的Nand Flash，被称作big block的Nand Flash，对应的发读写命令地址，一共5个周期(cycle)，而老的Nand Flash，页大小是256B，512B，这类的Nand Flash被称作small block，地址周期只有4个。

页Page，是读写操作的基本单位。

不过，也有例外的是，有些Nand Flash支持subpage（1/2页或1/4页）子页的读写操作，不过一般很少见。

每一个页，对应还有一块区域，叫做空闲区域（spare area）/冗余区域（redundant area），而Linux系统中，一般叫做OOB（Out Of Band），这个区域，是最初基于Nand Flash的硬件特性：数据在读写时候相对容易错误，所以为了保证数据的正确性，必须要有对应的检测和纠错机制，此机制被叫做EDC(Error Detection Code)/ECC（Error Code Correction, 或者 Error Checking and Correcting），所以设计了多余的区域，用于放置数据的校验值。

Oob的读写操作，一般是随着页的操作一起完成的，即读写页的时候，对应地就读写了oob。

关于oob具体用途，总结起来有：

1.2.6. Flash名称的由来

1.2.7. Flash相对于普通设备的特殊性

表 1.2. Flash和普通设备相比所具有的特殊性

1.2.8. Nand Flash的位反转特性

Nand Flash的位反转现象，主要是由以下一些原因/效应所导致：

位反转，说白了，就是读取数据的时候，数据出错了。

因此，如果你读取的数据正好是属于某个重要的文件中的数据，比如系统的配置文件等，那么此时错了一位，都会导致系统出现异常，问题相对会很严重。

而如果此数据属于音视频流中的数据，那么此时即使错了一位，对整个音视频的播放产生的影响也很小，所以问题也不大。

对应的位反转的类型，有两种：

以上两种类型的位反转，其实对于从Nand Flash读取出来的数据来说，解决其中的错误的位的方法，都是一样的，即通过一定的校验算法，常称为ECC，去检测出来，或检测并纠正错误。

如果只是单独检测错误，那么如果发现数据有误，那么再重新读取一次即可。

实际中更多的做法是，ECC校验发现有错误，会有对应的算法去找出哪位错误并且纠正过来。

其中对错误的检测和纠正，具体的实现方式，有软件算法，也有硬件实现，即硬件Nand Flash的控制器controller本身包含对应的硬件模块以实现数据的校验和纠错的。

1.2.9. Nand Flash引脚(Pin)的说明

图 1.4. Nand Flash引脚功能说明

表 1.3. Nand Flash引脚功能的中文说明

硬件上，有了电源的Vcc和接地的Vss等引脚，很好理解，但是为何还要有ALE和CLE这样的引脚，为何设计这么多的命令,把整个系统搞这么复杂，关于这点，最后终于想明白了：

设计命令锁存使能(Command Latch Enable, CLE) 和 地址锁存使能(Address Latch Enable，ALE)，那是因为，Nand Flash就8个I/O，而且是复用的，也就是，可以传数据，也可以传地址，也可以传命令，为了区分你当前传入的到底是啥，所以，先要用发一个CLE（或ALE）命令，告诉Nand Flash的控制器一声，我下面要传的是命令（或地址），这样，里面才能根据传入的内容，进行对应的动作。否则,Nand Flash内部,怎么知道你传入的是数据,还是地址,还是命令,也就无法实现正确的操作了。

在Nand Flash的硬件设计中，你会发现很多个引脚。关于硬件上为何设计这样的引脚，而不是直接像其他存储设备，比如普通的RAM，直接是一对数据线引出来，多么方便和好理解啊。

关于这样设计的好处：

1.2.10. Nand Flash的一些典型(typical)的特性

1. 页擦除时间是200us，有些慢的有800us
2. 块擦除时间是1.5ms
3. 页数据读取到数据寄存器的时间一般是20us
4. 串行访问（Serial access）读取一个数据的时间是25ns，而一些旧的Nand Flash是30ns，甚至是50ns
5. 输入输出端口是地址和数据以及命令一起multiplex复用的
6. Nand Flash的编程/擦除的寿命：即，最多允许的擦除的次数

   以前老的Nand Flash，编程/擦除时间比较短，比如K9G8G08U0M，才5K次，而后来的多数也只有10K=1万次，而现在很多新的Nand Flash，技术提高了，比如，Micron的MT29F1GxxABB，Numonyx的 NAND04G-B2D/NAND08G-BxC，都可以达到100K，也就是10万次的编程/擦除，达到和接近于之前常见的Nor Flash，几乎是同样的使用寿命了。

7. 封装形式

   48引脚的TSOP1封装 或 52引脚的ULGA封装

1.2.11. Nand Flash控制器与Nand Flash芯片

1.2.12. Nand Flash中的特殊硬件结构

图 1.5. Nand Flash读写时的数据流向

1.2.13. Nand Flash中的坏块(Bad Block)

坏块有两种：

具体标记的地方是，对于现在常见的页大小为2K的Nand Flash，是块中第一个页的oob起始位置（关于什么是页和oob，下面会有详细解释）的第1个字节（旧的小页面，pagesize是512B甚至256B的Nand Flash，坏块标记是第6个字节），如果不是0xFF，就说明是坏块。相对应的是，所有正常的块，好的块，里面所有数据都是0xFF的。

不过，对于现在新出的有些Nand Flash，很多标记方式，有些变化，有的变成该坏块的第一个页或者第二个页，也有的是，倒数最后一个或倒数第二个页，用于标记坏块的。

具体的信息，请参考对应的Nand Flash的数据手册，其中会有说明。

对于坏块的标记，本质上，也只是对应的flash上的某些字节的数据是非0xFF而已，所以，只要是数据，就是可以读取和写入的。也就意味着，可以写入其他值，也就把这个坏块标记信息破坏了。对于出厂时的坏块，一般是不建议将标记好的信息擦除掉的。

uboot中有个命令是

nand scrub

就可以将块中所有的内容都擦除了，包括坏块标记，不论是出厂时的，还是后来使用过程中出现而新标记的。一般来说，不建议用这个。

不过，在实际的驱动编程开发过程中，为了方便起见，我倒是经常用，其实也没啥大碍，呵呵。不过呢，其实最好的做法是，用

nand erase

只擦除好的块，对于已经标记坏块的块，不要轻易擦除掉，否则就很难区分哪些是出厂时就坏的，哪些是后来使用过程中用坏的了。

对于坏块的管理，在Linux系统中，叫做坏块管理（BBM，Bad Block Management），对应的会有一个表去记录好块，坏块的信息，以及坏块是出厂就有的，还是后来使用产生的，这个表叫做坏块表（BBT，Bad Block Table）。在Linux 内核MTD架构下的Nand Flash驱动，和Uboot中Nand Flash驱动中，在加载完驱动之后，如果你没有加入参数主动要求跳过坏块扫描的话，那么都会去主动扫描坏块，建立必要的BBT的，以备后面坏块管理所使用。

而关于好块和坏块，Nand Flash在出厂的时候，会做出保证：

一般来说，不同型号的Nand Flash的数据手册中，也会提到，自己的这个Nand Flash，最多允许多少个坏块。就比如上面提到的，三星的K9G8G08U0M，最多有100个坏块。

1.2.14. Nand Flash中页的访问顺序

1.2.15. 常见的Nand Flash的操作

图 1.6. Nand Flash K9K8G08U0A的命令集合

Nand flash的写操作叫做编程Program，编程，一般情况下，是以页为单位的。

有的Nand Flash，比如K9K8G08U0A，支持部分页编程（Partial Page Program），但是有一些限制：在同一个页内的，连续的部分页的编程，不能超过4次。

一般情况下，都是以页为单位进行编程操作的，很少使用到部分页编程。

关于这个部分页编程，本来是一个页的写操作，却用两个命令或更多的命令去实现，看起来是操作多余，效率不高，但是实际上，有其特殊考虑：

至少对于块擦除来说，开始的命令0x60是擦除设置命令(erase setup comman)，然后传入要擦除的块地址，然后再传入擦除确认命令（erase confirm command）0xD0，以开始擦除的操作。

这种完成单个操作要分两步发送命令的设计，即先开始设置，再最后确认的命令方式，是为了避免由于外部由于无意的/未预料而产生的噪音，比如，由于某种噪音，而产生了0x60命令，此时，即使被Nand Flash误认为是擦除操作，但是没有之后的确认操作0xD0，Nand Flash就不会去擦除数据，这样使得数据更安全，不会由于噪音而误操作。

下面以最简单的read操作为例，解释如何理解时序图，以及将时序图中的要求，转化为代码。

解释时序图之前，让我们先要搞清楚，我们要做的事情：

从Nand Flash的某个页Page里面，读取我们要的数据。

要实现此功能，会涉及到几部分的知识，即使我们不太懂Nand Flash的细节，但是通过前面的基本知识的介绍，那么以我们的常识，至少很容易想到的就是，需要用到哪些命令，怎么发这些命令，怎么计算所需要的地址，怎么读取我们要的数据等等。

下面就一步步的解释，需要做什么，以及如何去做：

1.2.15.2.2. 发送命令前的准备工作以及时序图各个信号的具体含义

知道了用何命令后，再去了解如何发送这些命令。

	提示
	在开始解释前，关于”使能”这个词要罗嗦一下，以防有些读者和我以前一样，在听这类词语的时候，属于初次接触，或者接触不多的，就很容易被搞得一头雾水的（虽然该词汇对于某些专业人士说是属于最基本的词汇了，囧）。 使能（Enable），是指使其（某个信号）有效，使其生效的意思，“使其”“能够”怎么怎么样。。。。比如，上面图中的CLE线号，是高电平有效，如果此时将其设为高电平，我们就叫做，将CLE使能，也就是使其生效的意思。

图 1.7. Nand Flash数据读取操作的时序图

	注意
	此图来自三星的型号K9K8G08U0A的Nand Flash的数据手册(datasheet)。

我们来一起看看，我在图6中的特意标注的①边上的黄色竖线。

黄色竖线所处的时刻，是在发送读操作的第一个周期的命令0x00之前的那一刻。

让我们看看，在那一刻，其所穿过好几行都对应什么值，以及进一步理解，为何要那个值。

1. 黄色竖线穿过的第一行，是CLE。还记得前面介绍命令所存使能（CLE）那个引脚吧？CLE，将CLE置1，就说明你将要通过I/O复用端口发送进入Nand Flash的，是命令，而不是地址或者其他类型的数据。只有这样将CLE置1，使其有效，才能去通知了内部硬件逻辑，你接下来将收到的是命令，内部硬件逻辑，才会将受到的命令，放到命令寄存器中，才能实现后面正确的操作，否则，不去将CLE置1使其有效，硬件会无所适从，不知道你传入的到底是数据还是命令了。
2. 而第二行，是CE#，那一刻的值是0。这个道理很简单，你既然要向Nand Flash发命令，那么先要选中它，所以，要保证CE#为低电平，使其有效，也就是片选有效。
3. 第三行是WE#，意思是写使能。因为接下来是往Nand Flash里面写命令，所以，要使得WE#有效，所以设为低电平。
4. 第四行，是ALE是低电平，而ALE是高电平有效，此时意思就是使其无效。而对应地，前面介绍的，使CLE有效，因为将要数据的是命令（此时是发送图示所示的读命令第二周期的0x30），而不是地址。如果在其他某些场合，比如接下来的要输入地址的时候，就要使其有效，而使CLE无效了。
5. 第五行，RE#，此时是高电平，无效。可以看到，知道后面低6阶段，才变成低电平，才有效，因为那时候，要发生读取命令，去读取数据。
6. 第六行，就是我们重点要介绍的，复用的输入输出I/O端口了，此刻，还没有输入数据，接下来，在不同的阶段，会输入或输出不同的数据/地址。
7. 第七行，R/B#,高电平，表示R（Ready）/就绪，因为到了后面的第5阶段，硬件内部，在第四阶段，接受了外界的读取命令后，把该页的数据一点点送到页寄存器中，这段时间，属于系统在忙着干活，属于忙的阶段，所以，R/B#才变成低，表示Busy忙的状态的。

介绍了时刻①的各个信号的值，以及为何是这个值之后，相信，后面的各个时刻，对应的不同信号的各个值，大家就会自己慢慢分析了，也就容易理解具体的操作顺序和原理了。

1.2.15.2.3. 如何计算出我们要传入的行地址和列地址

在介绍具体读取数据的详细流程之前，还要做一件事，那就是，先要搞懂我们要访问的地址，以及这些地址，如何分解后，一点点传入进去，使得硬件能识别才行。

此处还是以K9K8G08U0A为例，此Nand Flash，一共有8192个块，每个块内有64页，每个页是2K+64 Bytes。

假设，我们要访问其中的第7000个块中的第64页中的1208字节处的地址，此时，我们就要先把具体的地址算出来：

物理地址

=块大小×块号 ＋ 页大小×页号 ＋ 页内地址

=128K×7000 ＋ 2K×64 ＋ 1208

=0x36B204B8

接下来，我们就看看，怎么才能把这个实际的物理地址，转化为Nand Flash所要求的格式。

在解释地址组成之前，先要来看看其datasheet中关于地址周期的介绍：

图 1.8. Nand Flash的地址周期组成

结合图 1.7 “Nand Flash数据读取操作的时序图”中的2，3阶段，我们可以看出，此Nand Flash地址周期共有5个，2个列(Column)周期，3个行（Row）周期。

1. 对应地，列地址A0~A10，就是页内地址，地址范围是从0到2047。

   细心的读者可能注意到了，为何此处多出来个A11呢？

   这样从A0到A11，一共就是12位，可以表示的范围就是0~2¹²，即0~4096了。

   实际上，由于我们访问页内地址，可能会访问到oob的位置，即2048-2111这64个字节的范围内，所以，此处实际上只用到了2048～2111，用于表示页内的oob区域，其大小是64字节。

2. 对应地，A12～A30，称作页号，页的号码，可以定位到具体是哪一个页。

   A18～A30，表示对应的块号，即属于哪个块。

简单解释完了地址组成，那么就很容易分析上面例子中的地址了。

注意，下面这样的方法，是错误的：

0x36B204B8 = 11 0110 1011 0010 0000 0100 1011 1000，分别分配到5个地址周期就是：

1st周期	A7 ～ A0	1011 1000 = 0xB8
2nd周期	A11～ A8	0100 = 0x04
3rd周期	A19～A12	0010 0000 = 0x20
4th周期	A27～A20	0110 1011 = 0x6B
5th周期	A30～A28	11 = 0x03

	注意
	与图 1.7 “Nand Flash数据读取操作的时序图”中对应的，*L，意思是地电平，由于未用到那些位，datasheet中强制要求设为0，所以，才有上面的2nd周期中的高4位是0000.其他的A30之后的位也是类似原理，都是0。

而至于上述计算方法为何是错误的，那是因为上面计算过程中，把第11位的值，本来是属于页号的位A11，给算成页内地址里面的值了。

应该是这样计算，才是对的：

0x36B204B8 = 11 0110 1011 0010 0000 0100 1011 1000

1st周期	A7 ～ A0	1011 1000 = 0xB8
2nd周期	A10～ A8	100 = 0x04
3rd周期	A19～A12	010 0000 0 = 0x40
4th周期	A27～A20	110 1011 0 = 0xD6
5th周期	A30～A28	11 0 = 0x06

那有人会问了，上面表11中，不是明明写的A0到A30，其中包括A11，不是正好对应着此处地址中的bit0到bit30吗？

其实，我开始也是犯了同样的错误，误以为我们要传入的地址的每一位，就是对应着表11中的A0到A30呢，实际上，表11中的A11，是比较特殊的，只有当我们访问页内地址处于oob的位置，即属于2048~2111的时候，A11才会其效果，才会用A0-A11用来表示对应的某个属于2048~2111的某个值，属于oob的某个位置。

而我们此处的页内地址为2108，还没有超过2047呢，所以A11肯定是0。

这么解释，显得很绕，很难看懂。

换种方式来解释，就容易听懂了：

说白了，我们就是要访问第7000个块中的第64页中的1208字节处，对应着

页内地址

=1208

=0x4B8

页号

=块数×页数/块 + 块内的页号

= 7000×（128K/2K） + 64

= 7000×64 + 64

= 448064

=0x6D640

也就是，我们要访问0x6D640页内的0x4B8地址，这样很好理解吧,^_^。

然后对应的：

页内地址=0x4B8

分成两个对应的列地址，就变成

0x4B8 ：列地址1=0xB8，列地址2=0x04

页号=0x6D640，分成三个行号就是：

0x6D640：行号1=0x40，行号2=0xD6，行号3=0x06

再回头看看上面的计算方法，

最开始计算出来的：

列地址1=0xB8

列地址2=0x04

行号1=0x20

行号2=0x6B

行号3=0x03

是错误的。

而第二次计算正确的：

列地址1=0xB8

列地址2=0x04

行号1=0x40

行号2=0xD6

行号3=0x06

才是对的，也和我们此处自己手动计算，是一致的。

第一次之所以计算错，就是错误的把行地址的最低一位A11，放到列地址中的最高位了。

至此，才算把如何手动计算行地址和列地址，解释明白和正确了。

对应的，Linux的源码\drivers\mtd\nand\nand_base.c中，也是这样处理的：

static void nand_command_lp(struct mtd_info *mtd, unsigned int command,

                int column, int page_addr)

{

......

        /* Serially input address */

        if (column != -1) {

......

            chip->cmd_ctrl(mtd, column, ctrl); /* 发送Col Addr 1 */

            ctrl &= ~NAND_CTRL_CHANGE;

            chip->cmd_ctrl(mtd, column >> 8, ctrl); /* 发送Col Addr 2 */

        }

        if (page_addr != -1) {

            chip->cmd_ctrl(mtd, page_addr, ctrl); /* 发送Row Addr 1 */

            chip->cmd_ctrl(mtd, page_addr >> 8, /* 发送Row Addr 2 */

                       NAND_NCE | NAND_ALE);

            /* One more address cycle for devices > 128MiB */

            if (chip->chipsize > (128 << 20))

                chip->cmd_ctrl(mtd, page_addr >> 16, /* 发送Row Addr 3 */

                           NAND_NCE | NAND_ALE);

        }

}
                

	column，即页内地址，多数情况下，都是0，即使不是0，也可以直接通过将传入的地址除于页地址所得的余数，就是列地址了。
	page_addr即页号，也很简单，就是通过要访问的地址，除于页大小，即可得到。

因此，我们要访问第7000个块中的第64页中的1208字节处的话，所要传入的地址就是分5个周期：

分别传入两个列地址的：

列地址1=0xB8

列地址2=0x04

然后再传3个行地址的：

行号1=0x40

行号2=0xD6

行号3=0x06

这样硬件才能识别。

而接下来的内容，也就是介绍硬件是如何处理这些输入的。

1.2.16. Nand Flash的一些高级特性

很多Nand flash支持一个叫做CE don’t-care的技术，字面意思就是，不关心是否片选。

对此也许有人会问了，如果不片选，那还能对其操作吗？答案就是，这个技术，主要用在当时是不需要选中芯片，但是芯片内部却仍可以继续操作的这些情况：在某些应用，比如录音，音频播放等应用中，外部使用的微秒（us）级的时钟周期，此处假设是比较少的2us，在进行读取一页或者对页编程时，是对Nand Flash操作，这样的串行（Serial Access）访问的周期都是20/30/50ns，都是纳秒（ns）级的，此处假设是50ns，当你已经发了对应的读或写的命令之后，接下来只是需要Nand Flash内部去自己操作，将数据读取除了或写入进去到内部的数据寄存器中而已，此处，如果可以把片选取消，CE#是低电平有效，取消片选就是拉高电平，这样会在下一个外部命令发送过来之前，即微秒量级的时间里面，即2us－50ns≈2us，这段时间的取消片选，可以降低很少的系统功耗，但是多次的操作，就可以在很大程度上降低整体的功耗了。

总的来说就是：由于某些外部应用所需要的访问Nand Flash的频率比较低，而Nand Flash内部操作速度比较快，所以在针对Nand Flash的读或写操作的大部分时间里面，都是在等待外部命令的输入，同时却选中芯片，产生了多余的功耗，此“不关心片选”技术，就是在Nand Flash的内部的相对快速的操作（读或写）完成之后，就取消片选，以节省系统功耗。待下次外部命令/数据/地址输入来的时候，再选中芯片，即可正常继续操作了。这样，整体上，就可以大大降低系统功耗了。

	提示
	如果想要操作硬件Nand Flash芯片，先要将对应的CE#（低有效）片选信号拉低，选中该芯片，然后才能做接下来的读写操作所要做的发命令，发数据等动作。 Nand Flash的片选与否，功耗差别会有很大。如果数据没有记错的话，我之前遇到我们系统里面的Nand Flash的片选，大概有5个mA的电流输出呢，也许你对5mA没太多概念，给你说个数据你就知道了：当时为了针对MP3播放功耗进行优化，整个系统优化之后的待机功耗，也才10个mA左右的，所以节省5mA已经算是很不错的功耗优化了。

Copy-Back功能，简单的说就是，将一个页的数据，拷贝到另一个页。

如果没有Copy-Back功能，那么正常的做法就是，先要将那个页的数据拷贝出来放到内存的数据buffer中，读出来之后，再用写命令将这页的数据，写到新的页里面。

而Copy-Back功能的好处在于，不需要用到外部的存储空间，不需要读出来放到外部的buffer里面，而是可以直接读取数据到内部的页寄存器（page register）然后写到新的页里面去。

而且，为了保证数据的正确，要硬件支持EDC（Error Detection Code）的，否则，在数据的拷贝过程中，可能会出现错误，并且拷贝次数多了，可能会累积更多错误。

而对于错误检测来说，硬件一般支持的是512字节数据，对应有16字节用来存放校验产生的ECC数值，而这512字节一般叫做一个扇区。对于2K＋64字节大小的页来说，按照512字节分，分别叫做A，B，C，D区，而后面的64字节的oob区域，按照16字节一个区，分别叫做E，F，G，H区，对应存放A，B，C，D数据区的ECC的值。

Copy-Back编程的主要作用在于，去掉了数据串行读取出来，再串行写入进去的时间，所以，而这部分操作，是比较耗时的，所以此技术可以提高编程效率，提高系统整体性能。

对于有些新出的Nand Flash，支持同时对多个片进行编程，比如上面提到的三星的K9K8G08U0A，内部包含4片(Plane)，分别叫做Plane0，Plane1，Plane2，Plane3。.由于硬件上，对于每一个Plane，都有对应的大小是2048+64=2112字节的页寄存器（Page Register），使得同时支持多个Plane编程成为可能。 K9K8G08U0A支持同时对2个Plane进行编程。

不过要注意的是，只能对Plane0和Plane1或者Plane2和Plane3，同时编程，而不支持Plane0和Plane2同时编程。

多片同时编程，是针对一个chip里面的多个Plane来说的，

而此处的交错页编程，是指对多个chip而言的。

可以先对一个chip，假设叫chip1，里面的一页进行编程，然后此时，chip1内部就开始将数据一点点写到页里面，就出于忙的状态了，而此时可以利用这个时间，对出于就绪状态的chip2，也进行页编程，发送对应的命令后，chip2内部也就开始慢慢的写数据到存储单元里面去了，也出于忙的状态了。此时，再去检查chip1，如果编程完成了，就可以开始下一页的编程了，然后发完命令后，就让其内部慢慢的编程吧，再去检查chip2，如果也是编程完了，也就可以进行接下来的其他页的编程了。如此，交互操作chip1和chip2，就可以有效地利用时间，使得整体编程效率提高近2倍，大大提高Nand Flash的编程/擦写速度了。

在介绍此特性之前，先要说说，与Random Data Output In a Page相对应的是，普通的，正常的，sequential data output in a page。

正常情况下，我们读取数据，都是先发读命令，然后等待数据从存储单元到内部的页数据寄存器中后，我们通过不断地将RE#(Read Enale，低电平有效)置低，然后从我们开始传入的列的起始地址，一点点读出我们要的数据，直到页的末尾，当然有可能还没到页地址的末尾，就不再读了。所谓的顺序（sequential）读取也就是，根据你之前发送的列地址的起始地址开始，每读一个字节的数据出来，内部的数据指针就加1，移到下个字节的地址，然后你再读下一个字节数据，就可以读出来你要的数据了，直到读取全部的数据出来为止。

而此处的随机（random）读取，就是在你正常的顺序读取的过程中，先发一个随机读取的开始命令0x05命令，再传入你要将内部那个数据指针定位到具体什么地址，也就是2个cycle的列地址，然后再发随机读取结束命令0xE0，然后，内部那个数据地址指针，就会移动到你所制定的位置了，你接下来再读取的数据，就是从那个制定地址开始的数据了。

而Nand Flash数据手册里面也说了，这样的随机读取，你可以多次操作，没限制的。

请注意，上面你所传入的地址，都是列地址，也就是页内地址，也就是说，对于页大小为2K的Nand Flash来说，所传入的地址，应该是小于2048+64＝2112的。

不过，实际在Nand Flash的使用中，好像这种用法很少的。绝大多数，都是顺序读取数据。

1.3.1. Nand Flash相关规范 – ONFI和LBA

ONFI规范，即Open Nand Flash Interface specification。

ONFI是Intel主导的，其他一些厂家（Hynix，Micron，Numonyx，Phison ，SanDisk，Sony，Spansion等）参与制定的，统一了Nand Flash的操作接口。

所谓操作接口，就是那些对Nand Flash操作的命令等内容。

而所谓统一，意思是之前那些Nand Flash的操作命令等，都是各自为政，虽然大多数常见的Nand Flash的操作，比如page read的命令是0x00,0x30，page write的命令是0x80,0x10等，但是有些命令相关的内容，很特别且很重要的一个例子就是，每个厂家的Nand Flash的read id的命令，虽然都是0x90，但是读取出来的几个字节的含义，每个厂家定义的都不太一样。

因此，才有统一Nand Flash的操作接口这一说。

ONFI规范，官网可以下载的到：

http://onfi.org/specifications/

比如：

ONFI 2.2 Spec

http://onfi.org/wp-content/uploads/2009/02/ONFI%202_2%20Gold.pdf

ONFI规范中定义的Nand Flash的命令集合为：

图 1.13. ONFI中的Nand Flash的命令集合

可以看到，其中常见的一些命令，比如

等等命令，都是和普通的Nand Flash的命令是一样的，而额外多出一些命令，比如Read Unique ID（0xED）等命令，是之前某些Nand Flash命令所不具有的。

如此，定义了Nand Flash的操作的命令的集合以及发送对应命令所遵循的时序等内容。

LBA Nand Flash，Logical Block Address，逻辑块寻址的Nand Flash，是Nand Flash大厂之一的Toshiba，自己独立设计出来的新一代的Nand Flash的规范。

之所以叫做逻辑块寻址，是相对于之前常见的，普通的Nand Flash的物理块的寻址来说的。常见的Nand Flash，如果要读取和写入数据，所用的对应的地址是对应的：block地址+block内的Page地址+Page内的偏移量 = 绝对的物理地址，

此物理块寻址，相对来说有个缺点，那就是，由于之前提到的Nand Flash会出现使用过程中出现坏块，所以，遇到这样的坏块，首先坏块管理要去将此坏块标记，然后将坏块的数据拷贝到另一个好的block中，再继续访问新的block。

而且数据读写过程中，还要有对应的ECC校验，很多情况下，也都是软件来实现这部分的工作，即使是硬件的ECC校验，也要写少量的软件，去操作对应寄存器，读取ECC校验的结果，当然别忘了，还有对应的负载平衡等工作。

如此的这类的坏块管理工作，对于软件来说，很是繁重，而且整个系统实现起来也不是很容易，所以，才催生了一个想法，是否可以把ECC校验，负载平衡，坏块管理，全部都放到硬件实现上，而对于软件来说，我都不关心，只关心有多少个Block供我使用，用于数据读写。

针对于此需求，Toshiba推出了LBA逻辑块寻址的Nand Flash，在Nand Flash存储芯片之外，加了对应一个硬件控制权Controller，实现了上述的坏块管理，ECC校验，负载平衡等工作，这样使得人家想要用你LBA的Nand Flash的人，去开发对应的软件来驱动LBA Nand Flash工作，相对要做的事情，就少了很多，相对来说就是减轻了软件系统集成方面的工作，提高了开发效率，缩短了产品上市周期。

LBA Nand，最早放出对应的样片（sample）是在2006年8月。

网上找到一个LBA Nand Flash的简介：

http://www.toshiba-components.com/prpdf/5678E.pdf

现早已经量产，偶在之前开发过程中，就用过其某款LBA的Nand Flash。

目前网上还找不到免费的LBA的规范。除非你搞开发，和Toshiba签订NDA协议后，才可以拿到对应的specification。

关于Toshiba LBA Nand规范，在此多说一点（参考附录中：lba-core.c）：

LBA Nand分为PNP，VFP和MDP三种分区：

在解释为何会有ONFI和LBA之前，先来个背景介绍：

目前Nand Flash的厂家有Samsung，Toshiba，Intel， Hynix，Micron，Numonyx，Phison ，SanDisk，Sony，Spansion等。

总的来说，ONFI在对于旧的Nand Flash的兼容上，都是相对类似的。

1.3.2. 内存技术设备，MTD（Memory Technology Device）

表 1.4. MTD设备和硬盘设备之间的区别

关于nand flash，由于各个厂家的read id读出的内容的定义，都不同，导致，对于读出的id，分别要用不同的解析方法，下面这段代码，是我之前写的，本来打算自己写信去推荐到Linux MTD内核源码的，不过后来由于没搞懂具体申请流程，就放弃了。不过，后来，看到Linux的MTD部分更新了，加了和下面类似的做法。

此处只是为了记录下来，也算给感兴趣的人一个参考吧。

文件：\linux-2.6.28.4\drivers\mtd\nand\nand_base.c

/*

 * Get the flash and manufacturer id and lookup if the type is supported

 */

static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,

                          struct nand_chip *chip,

                          int busw, int *maf_id)

{

... ...

    chip->chipsize = (uint64_t)type->chipsize << 20;

    /* 针对不同的MLC和SLC的nand flash，添加了不同的解析其ID的方法 */

    /* Newer devices have all the information in additional id bytes */

    if (!type->pagesize) {

        int erase_bits, page_base, block_base, old_50nm, new_40nm;

        uint8_t id3rd, id4th, id5th, id6th, id7th;

        /* The 3rd id byte holds MLC / multichip data */

        chip->cellinfo = id3rd = chip->read_byte(mtd);

        /* The 4th id byte is the important one */

        id4th = chip->read_byte(mtd);

        id5th = chip->read_byte(mtd);

        id6th = chip->read_byte(mtd);

        id7th = chip->read_byte(mtd);

        /* printk(KERN_INFO " (ID:%02x %02x %02x %02x %02x %02x %02x) ",

            id1st, id2nd, id3rd, id4th, id5th, id6th, id7th); */

        if (nand_is_mlc(chip->cellinfo)) {

            /*

             * MLC:

             * 50nm has 5 bytes ID, further read ID will periodically output

             * 40nm has 6 bytes ID

             */

            /*

             * the 4th byte is not the same meaning for different manufature

            */

            if (NAND_MFR_SAMSUNG == *maf_id) {

                /* samsung MLC chip has several type ID meanings:

                (1)50nm serials, such as K9GAG08U0M

                (2)40nm serials, such as K9LBG08UXD

                */

                /* old 50nm chip will periodically output if read further ID */

                old_50nm = (id1st == id6th) && (id2nd == id7th);

                /* is 40nm or newer */

                new_40nm = id6th & 0x07;

                if ((!old_50nm) && new_40nm) {

                    /*

                     * Samsang

                     * follow algorithm accordding to datasheets of:

                     * K9LBG08UXD_1.3 (40nm),

                     * ID(hex): EC D7 D5 29 38 41

                     * this algorithm is suitable for new chip than 50nm

                     * such as K9GAG08u0D,

                     * ID(hex): EC D5 94 29 B4 41

                     */

                    int bit236;

                    /* Calc pagesize, bit0,bit1: page size */

                    page_base = (1 << 11);  /* 2KB */

                    mtd->writesize = page_base * (1 << (id4th & BIT01));

                    block_base = (1 << 17); /* 128 KB */

                    /* Calc block size, bit4,bit5,bit7: block size */

                    erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */

                    erase_bits |= (id4th >> 5) & BIT(2); /* get bit7 and combine them */

                    mtd->erasesize = block_base * (1 << erase_bits);

                    /* Calc oobsize, bit2,bit3,bit6: oob size */

                    bit236 = (id4th >> 2) & BIT01; /* get bit2,bit3 */

                    bit236 |= (id4th >> 4) & BIT(2); /* get bit6 and combine them */

                    switch (bit236) {

                    case 0x01:

                        mtd->oobsize = 128;

                        break;

                    case 0x02:

                        mtd->oobsize = 218;

                        break;

                    default:

                        /* others reserved */

                        break;

                    }

                }

                else {

                    /*

                     * Samsang

                     * follow algorithm accordding to datasheets of:

                     * K9GAG08U0M (50nm)

                     * this algorithm is suitable for old 50nm chip

                     */

                    goto slc_algorithm;

                }

            }

            else if (NAND_MFR_TOSHIBA == *maf_id) {

                /*

                 * Toshiba

                 * follow algorithm guess from ID of TC58NVG3D1DTG00:

                 * Toshiba MLC TC58NVG3D1DTG00 1GB 8bit 1chip

                 * 4K+218 512K+27K 3.3V, (ID:98 D3 94 BA 64 13 42)

                 */

                int bit23;

                /* Calc pagesize, bit0,bit1: page size */

                page_base = (1 << 10);  /* 1KB */

                mtd->writesize = page_base * (1 << (id4th & BIT01));

                block_base = (1 << 16); /* 64 KB */

                /* Calc block size, bit4,bit5: block size */

                erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */

                mtd->erasesize = block_base * (1 << erase_bits);

                /* Calc oobsize, use spare/redundant area bit */

                bit23 = (id4th >> 2) & BIT01; /* get bit2,bit3 */

                switch (bit23) {

                case 0x01:

                    mtd->oobsize = 128;

                    break;

                case 0x02:

                    mtd->oobsize = 218;

                    break;

                default:

                    /* others reserved */

                    break;

                }

                /* Get buswidth information: x8 or x16 */

                busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;

            }

            else if (NAND_MFR_MICRON == *maf_id) {

                /*

                 * Micron

                 * follow algorithm accordding to datasheets of:

                 * 29F32G08CBAAA

                 */

                int spare_area_size_bit;

                /* Calc pagesize, bit0,bit1: page size */

                page_base = (1 << 10);  /* 1KB */

                mtd->writesize = page_base * (1 << (id4th & 0x03));

                block_base = (1 << 16); /* 64 KB */

                /* Calc block size, bit4,bit5: block size */

                erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */

                mtd->erasesize = block_base * (1 << erase_bits);

                /* Calc oobsize, use spare/redundant area bit */

                spare_area_size_bit = (id4th >> 2) & BIT(0);

                if (spare_area_size_bit) /* special oob */

                    mtd->oobsize = 218;

                else /* normal */

                    mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;

                /* Get buswidth information: x8 or x16 */

                busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;

            }

            else {

                /*

                 * Others

                 * FIXME: update follow algrithm,

                 * according to different manufacture's chip's datasheet

                 */

                goto slc_algorithm;

            }

        }

        else {

            /*

             * SLC, only has 4 bytes ID, further read will output periodically, such as:

             * Hynix : HY27UG084G2M, only has 4 byte ID,

             * following read ID is periodically same as the 1st ~ 4th byte,

             * for HY27UG084G2M is : 0xAD 0xDC 0x80 0x15 0xAD 0xDC 0x80 0x15 .....

            */

slc_algorithm:

            /* Calc pagesize, bit0,bit1: page size */

            page_base = (1 << 10);  /* 1KB */

            mtd->writesize = page_base * (1 << (id4th & BIT01));

            block_base = (1 << 16); /* 64 KB */

            /* Calc block size, bit4,bit5: block size */

            erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */

            mtd->erasesize = block_base * (1 << erase_bits);

            /* Calc oobsize, use fixed ratio */

            mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;

            /* Get buswidth information: x8 or x16 */

            busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;

        }

    } else {

        /*

         * Old devices have chip data hardcoded in the device id table

         */

        mtd->erasesize = type->erasesize;

        mtd->writesize = type->pagesize;

        mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;

        busw = type->options & NAND_BUSWIDTH_16;

    }

    /*

    * 以上内容，主要是更加不同厂家的nand flash的datasheet，一点点总结出来的算法。

    * 最新的Linux的MTD部分，已经添加了类似如上部分的代码。此处贴出来，仅供参考。

    */

    /*

     * Check, if buswidth is correct. Hardware drivers should set

     * chip correct !

     */

    if (busw != (chip->options & NAND_BUSWIDTH_16)) {

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

        printk(KERN_WARNING "NAND bus width %d instead %d bit\n",

               (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,

               busw ? 16 : 8);

        return ERR_PTR(-EINVAL);

    }

... ...

}

1.3.3. 读操作的硬件到软件的映射

图 1.14. Nand Flash数据读取操作的时序图

1. 此阶段，是读命令第一个周期，发送的命令为0x00。
2. 此阶段，依次发送列地址，关于这些行地址，列地址等是如何计算出来的，后面的内容会有详细解释。
3. 此阶段是发送对应的行地址
4. 此阶段是发送读命令第二周期2nd cycle所对应的命令，0x30
5. 此阶段是等待时间，等待Nand Flash硬件上准备好对应的数据，以便后续读出。
6. 此阶段，就是一点点地把所需要的数据读出来。

static int nand_do_read_ops(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)

{

    ............

    while(1) {

        ......

        chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page); 

        ......

        ret = chip->ecc.read_page(mtd, chip, bufpoi, 

        buf += bytes;

        ......

        readlen - = bytes;

        if (! readlen)

        break;

        / * For subsequent reads align to page boundary. */

        col = 0;

        / * Increment page address */

        realpage++;

        page = realpage & chip->pagemask;

        ......

        }

    ......

    }

    ............

    return mtd->ecc_stats.corrected - stats.corrected ? - EUCLEAN : 0;

}
        

static void nand_command_lp(struct mtd_info *mtd, unsigned int command, int column, int page_addr)

{

    ......

    / * Command latch cycle */

    chip->cmd_ctrl(mtd, command & 0xff, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);

    if (column ! = - 1 | | page_addr ! = - 1) {

        int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;

        / * Serially input address */

        if (column ! = - 1) {

            / * Adjust columns for 16 bit buswidth */

            if (chip->options & NAND_BUSWIDTH_16)

            column >>= 1;

            chip->cmd_ctrl(mtd, column, ctrl);

            ctrl &= ~NAND_CTRL_CHANGE;

            chip->cmd_ctrl(mtd, column >> 8, ctrl);

        }

        if (page_addr ! = - 1) {

            chip->cmd_ctrl(mtd, page_addr, ctrl);

            chip->cmd_ctrl(mtd, page_addr >> 8, NAND_NCE | NAND_ALE);

            / * One more address cycle for devices > 128MiB */

            if (chip->chipsize > (128 << 20))

            chip->cmd_ctrl(mtd, page_addr >> 16, NAND_NCE | NAND_ALE);

        }

    }

    chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);

    / *

    * program and erase have their own busy handlers

    * status, sequential in, and deplete1 need no delay

    */

    switch (command) {

        ......

        case NAND_CMD_READ0:

            chip->cmd_ctrl(mtd, NAND_CMD_READSTART, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);

            chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);

            / * This applies to read commands */

        default:

        ......

    }

    / * Apply this short delay always to ensure that we do wait tWB in

    * any case on any machine. */

    /* */

    ndelay(100);

    nand_wait_ready(mtd);

}
        

static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, uint8_t *buf, int page)

{

    ......

    for (i = 0; eccsteps; eccsteps-- , i += eccbytes, p += eccsize) {

        chip->ecc.hwctl(mtd, NAND_ECC_READ);

        chip->read_buf(mtd, p, eccsize);

        chip->ecc.calculate(mtd, p, &ecc_calc[i]);

    }

    ......

}
        

static void s3c2410_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)

{

    struct nand_chip *this = mtd->priv;

    readsb(this->IO_ADDR_R, buf, len);

}
        

1.3.4. Nand flash驱动工作原理

	for (setno = 0; setno < nr_sets; setno++, nmtd++) {

		pr_debug("initialising set %d (%p, info %p)\n", setno, nmtd, info);

		s3c2410_nand_init_chip(info, nmtd, sets);

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

		if (nmtd->scan_res == 0) {

			s3c2410_nand_update_chip(info, nmtd);

			nand_scan_tail(&nmtd->mtd);

			s3c2410_nand_add_partition(info, nmtd, sets);

		}

		if (sets != NULL)

			sets++;

	}
        

2.1.1. 对于Nand Flash底层操作实现部分

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->write_buf    = s3c2410_nand_write_buf;

	chip->read_buf     = s3c2410_nand_read_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_S3C2410:

		chip->IO_ADDR_W = regs + S3C2410_NFDATA;

		info->sel_reg   = regs + S3C2410_NFCONF;

		info->sel_bit	= S3C2410_NFCONF_nFCE;

		chip->cmd_ctrl  = s3c2410_nand_hwcontrol;

		chip->dev_ready = s3c2410_nand_devready;

		break;

。。。。。。

  	}

	chip->IO_ADDR_R = chip->IO_ADDR_W;

	nmtd->info	   = info;

	nmtd->mtd.priv	   = chip;

	nmtd->mtd.owner    = THIS_MODULE;

	nmtd->set	   = set;

	if (hardware_ecc) {

		chip->ecc.calculate = s3c2410_nand_calculate_ecc;

		chip->ecc.correct   = s3c2410_nand_correct_data;

		chip->ecc.mode	    = NAND_ECC_HW;

		switch (info->cpu_type) {

		case TYPE_S3C2410:

			chip->ecc.hwctl	    = s3c2410_nand_enable_hwecc;

			chip->ecc.calculate = s3c2410_nand_calculate_ecc;

			break;

......

		}

	} else {

		chip->ecc.mode	    = NAND_ECC_SOFT;

	}

	if (set->ecc_layout != NULL)

		chip->ecc.layout = set->ecc_layout;

	if (set->disable_ecc)

		chip->ecc.mode	= NAND_ECC_NONE;

}
            

3.1.1. 三星(Samsung)的Nand Flash芯片的命名规则

3.1.2. 美光(Micron)的Nand Flash芯片的命名规则

3.1.3. 海力士(Hynix)的Nand Flash芯片的命名规则