Nor Flash测试方法有哪些 详解Nor Flash测试程序

　　本文主要是关于Nor Flash的相关介绍，并着重对Nor Flash测试方法及其程序进行了详尽的阐述。

　　Nor Flash

　　Nor Flash　　是现在市场上两种主要的非易失闪存技术之一。Intel于1988年首先开发出NOR Flash 技术，彻底改变了原先由EPROM（Erasable Programmable Read-Only-Memory电可编程序只读存储器）和EEPROM（电可擦只读存储器Electrically Erasable Programmable Read - Only Memory）一统天下的局面。紧接着，1989年，东芝公司发表了NAND Flash 结构，强调降低每比特的成本，有更高的性能，并且像磁盘一样可以通过接口轻松升级。NOR Flash 的特点是芯片内执行（XIP ，eXecute In Place），这样应用程序可以直接在Flash闪存内运行，不必再把代码读到系统RAM中。NOR 的传输效率很高，在1~4MB的小容量时具有很高的成本效益，但是很低的写入和擦除速度大大影响到它的性能。NAND的结构能提供极高的单元密度，可以达到高存储密度，并且写入和擦除的速度也很快。应用NAND的困难在于Flash的管理需要特殊的系统接口。通常读取NOR的速度比NAND稍快一些，而NAND的写入速度比NOR快很多，在设计中应该考虑这些情况。——《ARM嵌入式Linux系统开发从入门到精通》 李亚峰 欧文盛 等编著 清华大学出版社 P52 注释 API Key

　　性能比较

　　flash闪存是非易失存储器，可以对称为块的存储器单元块进行擦写和再编程。任何flash器件的写入操作只能在空或已擦除的单元内进行，所以大多数情况下，在进行写入操作之前必须先执行擦除。NAND器件执行擦除操作是十分简单的，而NOR则要求在进行擦除前先要将目标块内所有的位都写为0。

　　由于擦除NOR器件时是以64～128KB的块进行的，执行一个写入/擦除操作的时间为5s，与此相反，擦除NAND器件是以8～32KB的块进行的，执行相同的操作最多只需要4ms。

　　执行擦除时块尺寸的不同进一步拉大了NOR和NAND之间的性能差距，统计表明，对于给定的一套写入操作（尤其是更新小文件时），更多的擦除操作必须在基于NOR的单元中进行。这样，当选择存储解决方案时，设计师必须权衡以下的各项因素。

　　l 、NOR的读速度比NAND稍快一些。

　　2、 NAND的写入速度比NOR快很多。

　　3 、NAND的4ms擦除速度远比NOR的5s快。

　　4 、大多数写入操作需要先进行擦除操作。

　　5 、NAND的擦除单元更小，相应的擦除电路更少。

　　此外，NAND的实际应用方式要比NOR复杂的多。NOR可以直接使用，并可在上面直接运行代码；而NAND需要I/O接口，因此使用时需要驱动程序。不过当今流行的操作系统对NAND结构的Flash都有支持。此外，Linux内核也提供了对NAND结构的Flash的支持。

　　详解

　　NOR和NAND是现在市场上两种主要的非易失闪存技术。Intel于1988年首先开发出NOR flash技术，彻底改变了原先由EPROM和EEPROM一统天下的局面。紧接着，1989年，东芝公司发表了NAND flash结构，强调降低每比特的成本，更高的性能，并且象磁盘一样可以通过接口轻松升级。但是经过了十多年之后，仍然有相当多的硬件工程师分不清NOR和NAND闪存。

　　像“flash存储器”经常可以与相“NOR存储器”互换使用。许多业内人士也搞不清楚NAND闪存技术相对于NOR技术的优越之处，因为大多数情况下闪存只是用来存储少量的代码，这时NOR闪存更适合一些。而NAND则是高数据存储密度的理想解决方案。

　　NOR的特点是芯片内执行（XIP， eXecute In Place），这样应用程序可以直接在flash闪存内运行，不必再把代码读到系统RAM中。NOR的传输效率很高，在1～4MB的小容量时具有很高的成本效益，但是很低的写入和擦除速度大大影响了它的性能。

　　NAND结构能提供极高的单元密度，可以达到高存储密度，并且写入和擦除的速度也很快。应用NAND的困难在于flash的管理需要特殊的系统接口。

　　接口差别

　　NOR flash带有SRAM接口，有足够的地址引脚来寻址，可以很容易地存取其内部的每一个字节。

　　NAND器件使用复杂的I/O口来串行地存取数据，各个产品或厂商的方法可能各不相同。8个引脚用来传送控制、地址和数据信息。

　　NAND读和写操作采用512字节的块，这一点有点像硬盘管理此类操作，很自然地，基于NAND的存储器就可以取代硬盘或其他块设备。

　　容量成本

　　NAND flash的单元尺寸几乎是NOR器件的一半，由于生产过程更为简单，NAND结构可以在给定的模具尺寸内提供更高的容量，也就相应地降低了价格。

　　NOR flash占据了容量为1～16MB闪存市场的大部分，而NAND flash只是用在8～128MB的产品当中，这也说明NOR主要应用在代码存储介质中，NAND适合于数据存储，NAND在CompactFlash、Secure Digital、PC Cards和MMC（多媒体存储卡Multi Media Card）存储卡市场上所占份额最大。

　　Nor Flash测试方法有哪些

　　NorFlash简单来说与sdram与Nand的中间品，它能像sdram一样直接读，但是又得像nand一样编程擦写。因此程序可以直接在nor里跑，速度要比sdram慢一些，往nor里写数据必须先擦除，因为nor的每一位只能由1变为0。Nor可读不可直接写的特性可以被用来判断是Nor启动还是nand启动，因为nand启动的话前4K是可写的，我们写入数据再读取出来应该是没有问题的，而nor启动的话，读出的数据必然是错误的。

　　NorFlash的硬件接线：

　　首先，如果做过sdram实验的朋友应该知道，NorFlash与sdram很相似，只不过sdram位宽为32，NOR为16。在硬件连接上，Nor的地址线与cpu的地址线错开1位，sdram错开2位。简单分析一下：

　　32位的CPU地址线为32位，每一个地址对应1个byte，地址的步长为1byte

　　0x0000 0000 对应第1个地址空间 大小为1bytes

　　0x0000 0001 对应 2 大小为1bytes

　　依次类推。..

　　可以理解为cpu的地址类型 为 u8 * addraddr+1 移动1个字节

　　32位的sdram，每一个地址对应于4个byte，地址步长为4byte

　　0x0000 0000 对应第1个地址空间 大小为4bytes

　　0x0000 0001 对应 2 大小为4bytes

　　依次类推。..

　　可以理解为sdram的地址类型 为 u32 * addraddr+1 移动4个字节

　　16位的nor，每一个地址对应于2个byte，地址步长为2byte

　　0x0000 0000 对应第1个地址空间 大小为2bytes

　　0x0000 0001 对应 2 大小为2bytes

　　依次类推。..

　　可以理解为nor的地址类型 为 u16 * addraddr+1 移动2个字节

　　因此，CPU的地址与它们的地址是错位的。

　　CPU的4个连续地址 如 0 1 2 3 均对应于sdram的 0地址

　　CPU的2个连续地址 如 0 1 均对应于nor 的 0地址

　　假如我想取sdram 0地址的 第二个byte 地址如何写？对于sdram和nor具体的每一个byte是无法寻址的呀，但是arm有一个叫存储管理器的东西，它大概会帮我们实现单字节的读写，至于sdram和nor支不支持单字节读写，我们后边在分析。

　　NorFlash的软件设置：

　　需要像初始化sdram一样，设置Bank寄存器，主要是一些时序图的时间大小。

　　

　　位宽在BWSCON寄存器中设置，不过它是由硬件决定的，bank0的位宽，我们拨动开关选择nor启动还是nand启动的时候，它就已经确定了。

　　NorFlash信息：

　　我这款Nor大小为2M，32个Block，每个block分为16个sector，一个sector为4K，具体信息如下图。

　　NorFlash写、擦除、读芯片ID：

　　Nor可以像sdram一样直接读取，对于其它的操作，例如写、擦除、读信息等需要写特定的Date到特定的Addr。

　　这里尤其需要注意的是，Addr指的是nor地址线上看到的地址，相对于cpu也就是我们写程序的时候，需要将addr《《1，这样cpu错位的地址线发出的地址正好对上nor需求的地址。

　　对于擦除操作，nor支持按block、sector或者整片的擦除，整个擦除需要6个周期，以按sector擦除为例，前五个周期为往XXX里写XXX，最后一个周期将0X30写入要擦除的sector对应的首地址即可。

　　对于写操作，需要4个周期，前3个周期往XXX里写XXX，最后一个周期将Data写入addr，这里需要注意的是addr必须是半字对齐，data也要求为16bit。

　　对于读取信息的操作，主要是读ID的操作，前3个周期往XXX里写XXX，第四个周期去读特定的地址，对于DeviceID来说，A1-A19=0，A0=1，对于CPU来说就是0x1《《1.

　　NorFlash的等待：

　　NorFlash有三种方式，1中读硬件引脚，另外两种读地址线，主要用读地址线的两种方式。

　　1、Toggle

　　连续读两次相同地址的数据，看DQ6是否相等，相等则擦除或写完成

　　2、polling

　　读数据，看DQ7是否正确，正确则擦除完成。如果擦除的话DQ7应该等于1，写操作的话，对比数据的第7位。

　　还有，很重要的一点：

　　经过我的测试，sdram的单字节读取没有问题，但是Nor单字节读取的时候，读出的数据并不正确。比如我在0x00地址处写入了0xff11，单字节读取0x0理论上应该得到0x11，而我在实际实验的时候得到的却是0xff。也就是说nor在存储半字数据的时候高8位于低8位互换了。

　　［cpp］ view plain copy

　　#include “uart.h”

　　#define MAIN_SECT_SIZE （4*1024） /* 4 KB */

　　#define CMD_UNLOCK1 0x000000AA

　　#define CMD_UNLOCK2 0x00000055

　　#define CMD_ERASE_SETUP 0x00000080

　　#define CMD_ERASE_CONFIRM 0x00000030

　　#define CMD_PROGRAM 0x000000A0

　　#define MEM_FLASH_ADDR1 （*（volatile U16 *）（0x000005555 《《 1））

　　#define MEM_FLASH_ADDR2 （*（volatile U16 *）（0x000002AAA 《《 1））

　　#define U16 unsigned short

　　#define U32 unsigned long

　　#define U8 unsigned char

　　int write_hword （U32 dest， U16 data）;

　　typedef struct {

　　U32 size; /* total bank size in bytes */

　　U16 sector_count; /* number of erase units */

　　U32 flash_id; /* combined device & manufacturer code */

　　U32 start［512］; /* physical sector start addresses */

　　} flash_info_t;

　　/*-----------------------------------------------------------------------*/

　　void flash_id（）{

　　MEM_FLASH_ADDR1 = CMD_UNLOCK1;

　　MEM_FLASH_ADDR2 = CMD_UNLOCK2;

　　MEM_FLASH_ADDR1 = 0x00000090;

　　print（“Manufacturer ID ：%x\r\n”，*（（U16 *）0x00））;

　　MEM_FLASH_ADDR1 = CMD_UNLOCK1;

　　MEM_FLASH_ADDR2 = CMD_UNLOCK2;

　　MEM_FLASH_ADDR1 = 0x00000090;

　　print（“Device ID ：%x\r\n”，*（（U16 *）（0x01《《1）））;

　　}

　　void flash_init （） //计算总大小，每个sector的起始地址

　　{

　　flash_id（）;

　　//print（“flash init OK\r\n”）;

　　print（“*（（U32 *）0x32000000） = 0x00001100\r\n”）;

　　*（（U32 *）0x32000000） = 0x00001100;

　　print（“U8 0x32000001 == %x\r\n”，*（（U8 *）0x32000001））;

　　*（（U8 *）0x32000003） = 0xff;

　　print（“*（（U8 *）0x32000003） = 0xff\r\n”）;

　　print（“now the U32 0x32000000 should be 0xff001100\r\n”）;

　　print（“U32 0x32000000 = %x\r\n”，*（（U32 *）0x32000000））;

　　print（“U8 0x32000000 = %x\r\n”，*（（U8 *）0x32000000））;

　　print（“U8 0x32000001 = %x\r\n”，*（（U8 *）0x32000001））;

　　print（“U8 0x32000002 = %x\r\n”，*（（U8 *）0x32000002））;

　　print（“U8 0x32000003 = %x\r\n”，*（（U8 *）0x32000003））;

　　if（flash_erase（0，1） == 0）

　　print（“erase OK\r\n”）;

　　U32 a = 0x00001c15;

　　U16 b = 0x11ff;

　　write_hword（a，b）;

　　print（“*（U32 *0x00001c15） == 0x11ff\r\n”）;

　　print（“U8 0x1c15 = %x\r\n”，*（（U8 *）0x1c15））;

　　print（“U8 0x1c16 = %x\r\n”，*（（U8 *）0x1c16））;

　　print（“U16 0x1c15 = %x\r\n”，*（（U16 *）0x1c15））;

　　if（write_buff（（1024*20），0，（7*1024）） == 0）

　　print（“write OK\r\n”）;

　　}

　　int flash_erase （int s_first， int s_last）

　　{

　　int i，j;

　　U32 size = 0;

　　flash_info_t flash_info;

　　for （i = 0; i 《 1; i++） {

　　U32 flashbase = 0;

　　flash_info.size = 2*1024*1024;

　　flash_info.sector_count = 512;

　　flashbase = 0;

　　for （j = 0; j 《 flash_info.sector_count; j++） {

　　flash_info.start［j］ =

　　flashbase + （j） * MAIN_SECT_SIZE;

　　//print（“%d \t：%d\r\n”，j，flash_info.start［j］）;

　　}

　　}

　　int sect;

　　unsigned short temp;

　　/* Start erase on unprotected sectors */

　　for （sect = s_first; sect 《= s_last; sect++） {

　　print （“Erasing sector %d 。。。 \r\n”， sect+1）;

　　volatile U16 * addr = （volatile U16 *）（flash_info.start［sect］）;

　　MEM_FLASH_ADDR1 = CMD_UNLOCK1;

　　MEM_FLASH_ADDR2 = CMD_UNLOCK2;

　　MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;

　　MEM_FLASH_ADDR1 = CMD_UNLOCK1;

　　MEM_FLASH_ADDR2 = CMD_UNLOCK2;

　　*addr = CMD_ERASE_CONFIRM;

　　print（“wait\r\n”）;

　　while（1）{

　　temp = （*addr） & 0x40; // 0100 0000 DQ6

　　if（temp ！= （*addr） & 0x40） //DQ6

　　continue;

　　if（*addr & 0x80） //dq7 ==1

　　break;

　　}

　　}

　　return 0;

　　}

　　//写16位数据，地址应该是16位对齐的。

　　int write_hword （U32 dest， U16 data）

　　{

　　//print（“now to write %d\r\n”，dest）;

　　int rc;

　　volatile U16 *addr = （volatile U16 *）dest;

　　U16 result;

　　//Check if Flash is （sufficiently） erased

　　result = *addr;

　　if （（result & data） ！= data）

　　return 1;

　　MEM_FLASH_ADDR1 = CMD_UNLOCK1;

　　MEM_FLASH_ADDR2 = CMD_UNLOCK2;

　　MEM_FLASH_ADDR1 = CMD_PROGRAM;

　　*addr = data;

　　while（1）{

　　unsigned short i = *addr & 0x40;

　　if（i ！= （*addr & 0x40）） //D6 == D6

　　continue;

　　if（（*addr & 0x80） == （data & 0x80））{

　　rc = 0;

　　break; //D7 == D7

　　}

　　}

　　//print（“write %d OK\r\n”，dest）;

　　return rc;

　　}

　　int write_buff （U32 src， U32 addr， U32 len）

　　{

　　int rc;

　　U16 data; //16Bit？

　　if（addr % 2）{

　　print（“addr is not for 16bit align\n”）;

　　return 1;

　　}

　　while （len 》= 2） {

　　data = *（（volatile U16 *） src）;

　　if （（rc = write_hword （addr， data）） ！= 0） {

　　return （rc）;

　　}

　　src += 2;

　　addr += 2;

　　len -= 2;

　　}

　　return 0;

　　}

　　Nor Flash测试程序

　　写Flash需要用到以下的命令：

　　1.Read Array

　　2.Read Status Register

　　3.Clear Status Register

　　4.Write to Buffer

　　5.Block Erase

　　6.Clear Block Lock-Bits

　　具体如何操作 请看代码分析或者手册

　　写Flash “Byte/Word Program Flowchart”为2个总线周期

　　流程如下：

　　Start-》 Write 40H， Address-》 Read Status Register-》 SR.7 =？-》 Full Status Check if Desired-》 Byte/Word Program Complete

　　其中Write 40H， Address的指令如下：

　　Word/Byte Program SCS/BCS 2 （周期1Write X 0x40 or 0x10）（ 周期2Write PA PD） 1，12，13

　　PA = Address of memory location to be programmed.

　　PD = Data to be programmed at location PA. Data is latched on the rising edge of WE#.

　　下面是代码解释：

　　#define U32 unsigned int

　　#define U16 unsigned short

　　#define S32 int

　　#define S16 short int

　　#define U8 unsigned char

　　#define S8 char

　　//My Addr

　　#define MY_FLASHADDR 0x08040000//写入的目标地址

　　#define RAM_STARTADDR 0x30180000//数据在Ram中的开始得志

　　#define RAM_READOUT_STARTADDR 0x31000000//验证的地址

　　#define TIME_WAIT_FLASH 100//Flash命令执行后，等待的时间

　　//////////////////////////////////////////////////////////////////

　　void IntelFlashWrite（void）;

　　void delay（int）;// /Flash命令执行后，等待

　　void panic（int i）;

　　void clearstatusreg（void）;//出错后要清除状态寄存器

　　//////////////////////////////////////////////////////////////////

　　int main（）

　　{

　　IntelFlashWrite（）;

　　return 0;

　　}

　　void IntelFlashWrite（）

　　{

　　U16 temp; //16位数据线，所以用U16

　　U16 readfromflash，readfromram;

　　int i = 0;

　　int count = 0;

　　*（U16*）MY_FLASHADDR = 0x60;// 清除 Block Lock-Bits

　　delay（TIME_WAIT_FLASH）;//等一下

　　*（U16*）MY_FLASHADDR = 0xD0;// 清除 Block Lock-Bits，周期2操作

　　delay（TIME_WAIT_FLASH）;

　　*（U16*）MY_FLASHADDR = 0x20; //块擦除，虽然手册里没说要块擦除。但是我们的片子如果不擦除的话，有时候会写不进去。

　　delay（TIME_WAIT_FLASH）;

　　*（U16*）MY_FLASHADDR = 0xD0; //块擦除，周期2操作

　　delay（TIME_WAIT_FLASH）;

　　for（i = 0;i《=0x20000;i+=2，count = 0）//128k为一个block

　　{

　　readfromram = *（U16*）（RAM_STARTADDR+i）;//从ram中把数据读出来

　　*（U16*）（MY_FLASHADDR+i） = 0x40;//写操作，周期1

　　delay（TIME_WAIT_FLASH）;//等等

　　*（U16*）（MY_FLASHADDR+i） = readfromram;// 写操作，周期2

　　temp = *（U16*）（MY_FLASHADDR+i）;//After the program sequence is written， the device automatically outputs SRD when read

　　while（（（temp&0x80） == 0）&&（count《1000））

　　{

　　temp = *（U16*）（MY_FLASHADDR+i）;

　　count++;

　　}//读1000次状态寄存器，超过1000次，就终止。

　　if（count》=1000）//over time

　　{

　　count = 0;

　　while（1）;

　　}

　　else//读出状态寄存器

　　{

　　*（U16*）（MY_FLASHADDR+i） = 0xFF;//发出readarray命令

　　delay（10）;

　　readfromflash = *（U16*）（RAM_STARTADDR+i）;//从Flash读出刚才写入的数据

　　if（readfromflash！=readfromram）//相等就好了

　　{

　　count = 0;

　　temp = 0;

　　readfromram = 0;

　　readfromflash = 0;

　　while（1）;

　　}

　　}

　　if（（temp&0x8） == 0x8）//Programming to Voltage Error Detect

　　{

　　while（1）;

　　}

　　if（（temp&0x2） == 0x2）//Device Protect Detect

　　{

　　while（1）;

　　}

　　if（（temp&0x10） == 0x10）//Programming Error

　　{

　　while（1）;

　　}

　　count = 0;

　　temp = 0;

　　readfromram = 0;

　　readfromflash = 0;

　　}

　　while（1）;//写完了

　　}

　　void delay（int i）

　　{

　　volatile int j = 0;

　　volatile int q;

　　for（;j《=i;j++）

　　q = j*j;

　　}

　　void clearstatusreg（）

　　{

　　*（U16*）MY_FLASHADDR = 0x50;

　　}

　　结语

　　关于Nor Flash测试的相关介绍就到这了，如有不足之处欢迎指正。

相关阅读推荐：NAND flash和NOR flash的区别详解

相关阅读推荐：详细剖析NorFlash和NandFlash的区别