• TQ2440之Nand flash


    NOR和NAND是现在市场上两种主要的非易失闪存技术。大多数情况下NOR闪存只是用来存储少量的代码,而NAND则是高数据存储密度的理想解决方案。

    NOR的特点是程序可以在NOR上执行,这样应用程序可以直接在flash闪存内运行,不必再把代码读到系统RAM中。NOR的传输效率很高,在1~4MB的小容量时具有很高的成本效益,但是很低的写入和擦除速度大大影响了它的性能。
    NAND结构能提供极高的单元密度,可以达到高存储密度,并且写入和擦除的速度也很快。应用NAND的困难在于flash的管理和需要特殊的系统接口。

    二者比较各有优缺点:

      ● NOR的读速度比NAND稍快一些。
      ● NAND的写入速度比NOR快很多。
      ● NAND的4ms擦除速度远比NOR的5s快。
      ● 大多数写入操作需要先进行擦除操作。
      ● NAND的擦除单元更小,相应的擦除电路更少

    NAND flash 在嵌入式系统中的地位与PC机上的硬盘是类似的。用于保存系统运行所必需的操作系统,应用程序,用户数据,运行过程中产生的各类数据,系统掉电后数据不会护丢失.本文主要介绍关于NAND Flash的组织结构和编写程序的方法。

    NAND flash在对大容量的数据存储中发挥着重要的作用。但它的一个劣势是很容易产生坏块,因此在使用nandflash时,往往要利用校验算法发现坏块并标注出来,以便以后不再使用该坏块。nandflash没有地址或数据总线,如果是8位nandflash,那么它只有8个IO口,这8个IO口用于传输命令、地址和数据。nandflash主要以page(页)为单位进行读写,以block(块)为单位进行擦除。每一页中又分为main区和spare区,main区用于正常数据的存储,spare区用于存储一些附加信息,如块好坏的标记、块的逻辑地址、页内数据的ECC校验和等。

    TQ2440开发板上的的NAND flash芯片为K9F4G08U0B。该芯片为512M x 8 Bits NAND Flash存储器。

    S3C2440内部集成了一个Nand flash控制器。S3C2440Nand flash控制器包含了如下的特性:

    1. 一个引导启动单元

    2.Nand Flash存储器接口,支持8位或16位的每页大小为256字,512字节,1K字和2K字节的Nand flash

    3. 软件模式:用户可以直接访问Nand Flash存储器,此特性可以用于Nand Flash 存储器的读、擦除和编程。

    4. S3C2440支持8/16位的Nand Flash存储器接口总线

    5.硬件ECC生成,检测和指示(软件纠错)。

    6. Steppingstone接口,支持大/小端模式的按字节/半字/字访问。

    Nand Flash的电路连接如图下图所示:

    Nand Flash是接在Nand Flash控制器上而不是系统总线上,所以没有在8个bank区分配地址。

      

    配置引脚NCON,GPG13,GPG14和GPG15用来设置Nand Flash的基本信息,Nand控制器通过读取配置引脚的状态获取外接的Nand Flash的配置信息,这四个配置引脚的定义如下图所示:

    由于KK9F4G08U0B的总线宽度为8位,页大小为2048字节,需要5个寻址命令,所以NCON、GPG13和GPG14应该接高电平,GPG15应该接低电平。

    K9F4G08U0B没有地址或数据总线,只有8个IO口,这8个IO口用于传输命令、地址和数据。K9F2G08U0A主要以page(页)为单位进行读写,以block(块)为单位进行擦除。每一页中又分为main区和spare区,main区用于正常数据的存储,spare区用于存储一些附加信息,如块好坏的标记、块的逻辑地址、页内数据的ECC校验和等。

    K9F4G08U0B的存储阵列组织如下图所示:

    K9F4G08U0B的地址序列如下图所示:

    要实现用8个IO口来要访问这么大的容量,K9F4G08U0B规定了用5个周期来实现。第一个周期访问的地址为A0~A7;第二个周期访问的地址为A8~A11,它作用在IO0~IO3上,而此时IO4~IO7必须为低电平;第三个周期访问的地址为A12~A19;第四个周期访问的地址为A20~A27;第五个周期访问的地址为A28,它作用在IO0上,而此时IO1~IO7必须为低电平。前两个周期传输的是列地址,后三个周期传输的是行地址。通过分析可知,列地址是用于寻址页内空间,行地址用于寻址页,如果要直接访问块,则需要从地址A18开始。由于所有的命令、地址和数据全部从8位IO口传输,所以Nand flash定义了一个命令集来完成各种操作。有的操作只需要一个命令(即一个周期)即可,而有的操作则需要两个命令(即两个周期)来实现。

    K9F4G08U0B的命令说明:

    Nand Flash控制器的寄存器主要有:

    NFCONF(Nand Flash配置寄存器)----2440的NFCONF寄存器是用来设置NAND Flash的时序参数TACLS、TWRPH0、TWRPH1。配置寄存器的[3:0]是只读位,用来指示外部所接的Nand Flash的配置信息,它们是由配置引脚NCON,GPG13,GPG14和GPG15所决定的(比如说K9F4G08U0B的配置为NCON、GPG13和GPG14接高电平,GPG15接低电平,所以[3:0]位状态应该是1110)。

    NFCONT(Nand Flash控制寄存器)----用来使能/禁止NAND Flash控制器、使能/禁止控制引脚信号nFCE、初始化ECC。它还有其他功能,在一般的应用中用不到,比如锁定NAND Flash。

    NFCMMD(Nand Flash命令集寄存器)----对于不同型号的Flash,操作命令一般不一样。参考前面介绍的K9F4G08U0B命令序列。

    NFADDR(Nand Flash地址集寄存器)----当写这个寄存器时,它将对Flash发出地址信号。只用到低8位来传输,所以需要分多次来写入一个完整的32位地址,K9F4G08U0B的地址序列在文中已经做了详细说明。

    NFDATA(Nand Flash数据寄存器)----只用到低8位,读、写此寄存器将启动对NAND Flash的读数据、写数据操作。

    NFMECCD0/1(Nand Flash的main区ECC寄存器)

    NFSECCD(Nand Flash的spare区ECC寄存器)

    NFSTAT(Nand Flash操作状态寄存器)----只用到位0,用来检测NAND是否准备好。0:busy,1:ready。

    NFESTAT0/1(Nand Flash的ECC状态寄存器)

    NFMECC0/1(Nand Flash用于数据的ECC状态寄存器)

    NFSECC(Nand Flash用于spare的ECC状态寄存器)

    NFCONF寄存器使用TACLS、TWRPH0、TWRPH1这3个参数来控制NAND Flash信号线CLE/ALE与写控制信号nWE的时序关系,它们之间的关系如下图所示:

             TACLS为CLE/ALE有效到nWE有效之间的持续时间,TWRPH0为nWE的有效持续时间,TWRPH1为nWE无效到CLE/ALE无效之间的持续时间,这些时间都是以HCLK为单位的。通过查阅K9F4G08U0B的数据手册,我们可以找到并计算与S3C2440相对应的时序:K9F4G08U0B中的Twp与TWRPH0相对应Tclh与TWRPH1相对应TACLS应该是与Tcls相对应。K9F4G08U0B给出的都是最小时间, 2440只要满足它的最小时间即可。TACLS、TWRPH0、TWRPH1这三个变量取值大一些会更保险,在这里,这三个值分别取1,2和0。

    下面就开始详细介绍K9F4G08U0B的基本操作,包括复位,读ID,页读、写数据,随意读、写数据,块擦除等。

    为了方便,我们宏定义了K9F4G08U0B的常用命令:

    #define CMD_READ1                0x00              //页读命令周期1
    
    #define CMD_READ2                0x30              //页读命令周期2
    
    #define CMD_READID               0x90              //读ID命令
    
    #define CMD_WRITE1               0x80              //页写命令周期1
    
    #define CMD_WRITE2               0x10              //页写命令周期2
    
    #define CMD_ERASE1               0x60              //块擦除命令周期1
    
    #define CMD_ERASE2               0xd0              //块擦除命令周期2
    
    #define CMD_STATUS               0x70                //读状态命令
    
    #define CMD_RESET                0xff                   //复位
    
    #define CMD_RANDOMREAD1          0x05       //随意读命令周期1
    
    #define CMD_RANDOMREAD2          0xE0       //随意读命令周期2
    
    #define CMD_RANDOMWRITE          0x85       //随意写命令
    
    #define NF_nFCE_L()        {rNFCONT &= ~(1<<1); }
    
    #define NF_CE_L()          NF_nFCE_L()    //打开nandflash片选
    
    #define NF_nFCE_H()        {rNFCONT |= (1<<1); }
    
    #define NF_CE_H()          NF_nFCE_H()        //关闭nandflash片选
    
    #define NF_RSTECC()        {rNFCONT |= (1<<4); }   //复位ECC
    
    #define NF_MECC_UnLock()   {rNFCONT &= ~(1<<5); }  //解锁main区ECC
    
    #define NF_MECC_Lock()     {rNFCONT |= (1<<5); }   //锁定main区ECC
    
    #define NF_SECC_UnLock()   {rNFCONT &= ~(1<<6); }   //解锁spare区ECC
    
    #define NF_SECC_Lock()     {rNFCONT |= (1<<6); }   //锁定spare区ECC
    
    #define NF_WAITRB()                  {while(!(rNFSTAT &  (1<<0) ) ); }  //等待Nand Flash不忙
    
    #define NF_CLEAR_RB()  {rNFSTAT |= (1<<2); }   //清除RnB信号
    
    #define NF_DETECT_RB()   {while(!(rNFSTAT&(1<<2)));}   //等待RnB信号变高,即不忙
    #define NF_CMD(data)       {rNFCMD  = (data); }       //传输命令
    
    #define NF_ADDR(addr)      {rNFADDR = (addr); }       //传输地址
    
    #define NF_RDDATA()         (rNFDATA)                  //读32位数据
    
    #define NF_RDDATA8()       (rNFDATA8)                 //读8位数据
    
    #define NF_WRDATA(data)    {rNFDATA = (data); }       //写32位数据
    
    #define NF_WRDATA8(data)    {rNFDATA8 = (data); }     //写8位数据

    芯片初始化:

    void rNF_Init(void)
    {
        rNFCONF = (TACLS<<12)|(TWRPH0<<8)|( TWRPH1<<4)|(0<<0);    //初始化时序参数
        rNFCONT = 
    (0<<13)|(0<<12)|(0<<10)|(0<<9)|(0<<8)|(1<<6)|(1<<5)|(1<<4)|(1<<1)|(1<<0);     //非锁定,屏蔽nandflash中断,初始化ECC及锁定main区和spare区ECC,
                                                  使能nandflash控制器,禁止片选
    rNF_Reset(); //复位芯片 }

    芯片复位:

    static void rNF_Reset()
    {
        NF_CE_L();                   //打开nandflash片选
        NF_CLEAR_RB();               //清除RnB信号
        NF_CMD(CMD_RESET);           //写入复位命令
        NF_DETECT_RB();              //等待RnB信号变高,即不忙
        NF_CE_H();                   //关闭nandflash片选
    }

     读芯片ID:

    static char rNF_ReadID()
    {
           char pMID;
           char pDID;
           char cyc3, cyc4, cyc5;
           NF_nFCE_L();              //打开nandflash片选
           NF_CLEAR_RB();            //清RnB信号
           NF_CMD(CMD_READID);       //读ID命令
           NF_ADDR(0x0);             //写0x00地址
           for ( i = 0; i < 100; i++ );等一段时间
           //读五个周期的ID
           pMID = NF_RDDATA8();      //厂商ID:0xEC
           pDID = NF_RDDATA8();      //设备ID:0xDA
           cyc3 = NF_RDDATA8();      //0x10
           cyc4 = NF_RDDATA8();      //0x95
           cyc5 = NF_RDDATA8();      //0x44
           NF_nFCE_H();              //关闭nandflash片选
           return (pDID);
    }

    下面介绍Nand Flash读操作,读操作是以页为单位进行的。如果在读取数据的过程中不进行ECC校验判断,则读操作比较简单,在写入读命令的两个周期之间写入要读取的页地址,然后读取数据即可。如果为了更准确地读取数据,则在读取完数据之后还要进行ECC校验判断,以确定所读取的数据是否正确。

    在上文中已经介绍过,Nand Flash的每一页有两区:main区和spare区,main区用于存储正常的数据,spare区用于存储其他附加信息,其中就包括ECC校验码。当我们在写入数据的时候,我们就计算这一页数据的ECC校验码,然后把校验码存储到spare区的特定位置中,在下次读取这一页数据的时候,同样我们也计算ECC校验码,然后与spare区中的ECC校验码比较,如果一致则说明读取的数据正确,如果不一致则不正确。

    ECC的算法较为复杂,好在S3C2440能够硬件产生ECC校验码,这样就省去了不少的麻烦事。S3C2440既可以产生main区的ECC校验码,也可以产生spare区的ECC校验码。因为K9F4G08U0B是8位IO口,因此S3C2440共产生4个字节的main区ECC码和2个字节的spare区ECC码。在这里我们规定,在每一页的spare区的第0个地址到第3个地址存储main区ECC,第4个地址和第5个地址存储spare区ECC。

    产生ECC校验码的过程为:在读取或写入哪个区的数据之前,先解锁该区的ECC,以便产生该区的ECC。在读取或写入完数据之后,再锁定该区的ECC,这样系统就会把产生的ECC码保存到相应的寄存器中。main区的ECC保存到NFMECC0/1中(因为K9F4G08U0B是8位IO口,因此这里只用到了NFMECC0),spare区的ECC保存到NFSECC中。对于读操作来说,我们还要继续读取spare区的相应地址内容,以得到上次写操作时所存储的main区和spare区的ECC,并把这些数据分别放入NFMECCD0/1NFSECCD的相应位置中。最后我们就可以通过读取NFESTAT0/1(因为K9F4G08U0B是8位IO口,因此这里只用到了NFESTAT0)中的低4位来判断读取的数据是否正确,其中第0位和第1位为main区指示错误,第2位和第3位为spare区指示错误。

    页读操作:

    U8 rNF_ReadPage( U32 page_number )
    {
        U32 i, mecc0, secc;
        NF_RSTECC();                           //复位ECC
        NF_MECC_UnLock();                  //解锁main区ECC
        NF_nFCE_L();                //使能芯片  
        NF_CLEAR_RB();                //清除RnB
        NF_CMD(CMD_READ1);          //页读命令周期1,0x00
        //写入5个地址周期
        NF_ADDR(0x00);                  //列地址A0-A7
        NF_ADDR(0x00);                  //列地址A8-A11
        NF_ADDR((page_number) & 0xff);           //行地址A12-A19
        NF_ADDR((page_number >> 8) & 0xff);    //行地址A20-A27
        NF_ADDR((page_number >> 16) & 0xff);   //行地址A28
        NF_CMD(CMD_READ2);                //页读命令周期2,0x30
        NF_DETECT_RB();                   //等待RnB信号变高,即不忙
        for (i = 0; i < 2048; i++)
        {
            buf[i] =  NF_RDDATA8();        //读取一页数据内容
        }
        NF_MECC_Lock();          //锁定main区ECC值
        NF_SECC_UnLock();        //解锁spare区ECC
        //读spare区的前4个地址内容,即第2048~2051地址,这4个字节为main区的ECC
        mecc0=NF_RDDATA();   
        //把读取到的main区的ECC校验码放入NFMECCD0/1的相应位置内
        rNFMECCD0=((mecc0&0xff00)<<8))|(mecc0&0xff);
        rNFMECCD1=((mecc0 & 0xff00  0000)>>8)|((mecc0 & 0xff0  000)>>16);
        NF_SECC_Lock();       //锁定spare区的ECC值
        //继续读spare区的4个地址内容,即第2052~2055地址,其中前2个字节为spare区的ECC值
        secc=NF_RDDATA();  
        //把读取到的spare区的ECC校验码放入NFSECCD的相应位置内
        rNFSECCD=((secc&0xff00)<<8)|(secc&0xff);
        NF_nFCE_H();               //关闭nandflash片选
        //判断所读取到的数据是否正确
        if ((rNFESTAT0&0xf) == 0x0)
        return 0x66;                  //正确
        else 
        return 0x44;                  //错误
    }

    页写操作:

    在两个写命令周期之间分别写入页地址和数据,当然如果为了保证下次读取该数据时的正确性,还需要把main区的ECC值和spare区的ECC值写入到该页的spare区内。然后我们还需要读取状态寄存器,以判断这次写操作是否正确。

    U8 rNF_WritePage(U32 page_number)
    {
        U32 i, mecc0, secc;
        U8 stat, temp;
        temp = rNF_IsBadBlock(page_number>>6);     //判断该块是否为坏块
        if(temp == 0x33)
        return 0x42;               //是坏块,返回
        NF_RSTECC();          //复位ECC-->使能ECC
        NF_MECC_UnLock();     //解锁main区的ECC
        NF_nFCE_L();          //打开nandflash片选
        NF_CLEAR_RB();        //清RnB信号
        NF_CMD(CMD_WRITE1);           //页写命令周期1
        //写入5个地址周期
        NF_ADDR(0x00);           //列地址A0~A7
        NF_ADDR(0x00);           //列地址A8~A11
        NF_ADDR((page_number) & 0xff);         //行地址A12~A19
        NF_ADDR((page_number >> 8) & 0xff);    //行地址A20~A27
        NF_ADDR((page_number >> 16) & 0xff);  //行地址A28
        for (i = 0; i < 2048; i++)//写入一页数据
        {
            NF_WRDATA8((char)(i+6));    
        }
        NF_MECC_Lock();    //锁定main区的ECC值
        mecc0=rNFMECC0;    //读取main区的ECC校验码
        //把ECC校验码由字型转换为字节型,并保存到全局变量数组ECCBuf中
        ECCBuf[0]=(U8)(mecc0&0xff);
        ECCBuf[1]=(U8)((mecc0>>8) & 0xff);
        ECCBuf[2]=(U8)((mecc0>>16) & 0xff);
        ECCBuf[3]=(U8)((mecc0>>24) & 0xff);
        NF_SECC_UnLock();                  //解锁spare区的ECC
        //把main区的ECC值写入到spare区的前4个字节地址内,即第2048~2051地址
        for(i=0;i<4;i++) 
        {
            NF_WRDATA8(ECCBuf[i]);
        }
        NF_SECC_Lock();                 //锁定spare区的ECC值
        secc=rNFSECC;                   //读取spare区的ECC校验码
        //把ECC校验码保存到全局变量数组ECCBuf中
        ECCBuf[4]=(U8)(secc&0xff);
        ECCBuf[5]=(U8)((secc>>8) & 0xff);
        //把spare区的ECC值继续写入到spare区的第2052~2053地址内
        for(i=4;i<6;i++)
        {
            NF_WRDATA8(ECCBuf[i]);
        }
        NF_CMD(CMD_WRITE2);              //页写命令周期2
        delay(1000);                            //延时一段时间,以等待写操作完成
        NF_CMD(CMD_STATUS);              //读状态命令
        //判断状态值的第6位是否为1,即是否在忙,该语句的作用与NF_DETECT_RB();相同
        do{
        stat = NF_RDDATA8();
        }while(!(stat&0x40));
        NF_nFCE_H();                    //关闭Nand Flash片选
        //判断状态值的第0位是否为0,为0则写操作正确,否则错误
        if (stat & 0x1)
        {
            temp = rNF_MarkBadBlock(page_number>>6);//标注该页所在的块为坏块
            if (temp == 0x21)
                return 0x43            //表示写操作失败,并且在标注该页所在的块为坏块时也失败
            else
                return 0x44;           //写操作失败
        }
        else 
            return 0x66;                  //写操作成功
    }

    擦除操作:
    擦除是以块为单位进行的,因此在写地址周期时,只需写三个行周期,并且要从A18开始写起。与写操作一样,在擦除结束前还要判断是否擦除操作成功,另外同样也存在需要判断是否为坏块以及要标注坏块的问题。

    U8 rNF_EraseBlock(U32 block_number)
    {
        char stat, temp;
        temp = rNF_IsBadBlock(block_number);     //判断该块是否为坏块
        if(temp == 0x33)
        return 0x42;           //是坏块,返回
        NF_nFCE_L();             //打开片选
        NF_CLEAR_RB();        //清RnB信号    
        NF_CMD(CMD_ERASE1);    //擦除命令周期1
        //写入3个地址周期,从A18开始写起
        NF_ADDR((block_number << 6) & 0xff);         //行地址A18~A19
        NF_ADDR((block_number >> 2) & 0xff);         //行地址A20~A27
        NF_ADDR((block_number >> 10) & 0xff);        //行地址A28    
        NF_CMD(CMD_ERASE2);         //擦除命令周期2
        delay(1000);          //延时一段时间
        NF_CMD(CMD_STATUS);          //读状态命令
        //判断状态值的第6位是否为1,即是否在忙,该语句的作用与NF_DETECT_RB();相同
        do{
            stat = NF_RDDATA8();
        }while(!(stat&0x40));
        NF_nFCE_H();             //关闭Nand Flash片选    
        //判断状态值的第0位是否为0,为0则擦除操作正确,否则错误
        if (stat & 0x1)
        {
            temp = rNF_MarkBadBlock(page_number>>6);    //标注该块为坏块
            if (temp == 0x21)
                return 0x43            //标注坏块失败
            else
                return 0x44;           //擦除操作失败
        }
        else 
            return 0x66;                  //擦除操作成    ?
    }

    K9F4G08U0B除了提供了页读和页写功能外,还提供了页地址随意读、写功能。页读和页写是从页的首地址开始读、写,而随意读、写实现了在一页范围内任意地址的读、写。随意读操作是在页读操作后输入随意读命令和页内列地址,这样就可以读取到列地址所指定地址的数据。随意写操作是在页写操作的第二个页写命令周期前,输入随意写命令和页内列地址,以及要写入的数据,这样就可以把数据写入到列地址所指定的地址内。下面两段程序实现了随意读和随意写功能,其中随意读程序的输入参数分别为页地址和页内地址,输出参数为所读取到的数据,随意写程序的输入参数分别为页地址,页内地址,以及要写入的数据。

    随意读:

    U8 rNF_RamdomRead(U32 page_number, U32 add)
    {
        NF_nFCE_L();                    //打开Nand Flash片选
        NF_CLEAR_RB();               //清RnB信号
        NF_CMD(CMD_READ1);           //页读命令周期1
        //写入5个地址周期
        NF_ADDR(0x00);           //列地址A0~A7
        NF_ADDR(0x00);       //列地址A8~A11
        NF_ADDR((page_number) & 0xff);     //行地址A12~A19
        NF_ADDR((page_number >> 8) & 0xff);           //行地址A20~A27
        NF_ADDR((page_number >> 16) & 0xff);         //行地址A28 
        NF_CMD(CMD_READ2);          //页读命令周期2
        NF_DETECT_RB();                    //等待RnB信号变高,即不忙
        NF_CMD(CMD_RANDOMREAD1);   //随意读命令周期1
        //页内地址
        NF_ADDR((char)(add&0xff));                  //列地址A0~A7
        NF_ADDR((char)((add>>8)&0x0f));           //列地址A8~A11    
        NF_CMD(CMD_RANDOMREAD2);            //随意读命令周期2
        return NF_RDDATA8();               //读取数据
    }

    随意写:

    U8 rNF_RamdomWrite(U32 page_number, U32 add, U8 dat)
    {
        U8 temp,stat;
        NF_nFCE_L();                    //打开Nand Flash片选
        NF_CLEAR_RB();               //清RnB信号
        NF_CMD(CMD_WRITE1);                //页写命令周期1
        //写入5个地址周期
        NF_ADDR(0x00);                                     //列地址A0~A7
        NF_ADDR(0x00);                                     //列地址A8~A11
        NF_ADDR((page_number) & 0xff);           //行地址A12~A19
        NF_ADDR((page_number >> 8) & 0xff);    //行地址A20~A27
        NF_ADDR((page_number >> 16) & 0xff);  //行地址A28    
        NF_CMD(CMD_RANDOMWRITE);                 //随意写命令
        //页内地址
        NF_ADDR((char)(add&0xff));                   //列地址A0~A7
        NF_ADDR((char)((add>>8)&0x0f));          //列地址A8~A11    
        NF_WRDATA8(dat);                          //写入数据
        NF_CMD(CMD_WRITE2);                //页写命令周期2  
        delay(1000);                 //延时一段时间  
        NF_CMD(CMD_STATUS);      //读状态命令
        //判断状态值的第6位是否为1,即是否在忙,该语句的作用与NF_DETECT_RB();相同
        do{
            stat =  NF_RDDATA8();
        }
        while(!(stat&0x40));
        NF_nFCE_H();                    //关闭Nand Flash片选
        //判断状态值的第0位是否为0,为0则写操作正确,否则错误
        if (stat & 0x1)
            return 0x44;                  //失败
        else 
            return 0x66;                  //成    ?
    }

    下面介绍上文中提到的判断坏块以及标注坏块的那两个程序:rNF_IsBadBlock和rNF_MarkBadBlock。在这里,我们定义在spare区的第6个地址(即每页的第2054地址)用来标注坏块,0x44表示该块为坏块。要判断坏块时,利用随意读命令来读取2054地址的内容是否为0x44,要标注坏块时,利用随意写命令来向2054地址写0x33。下面就给出这两个程序,它们的输入参数都为块地址,也就是即使仅仅一页出现问题,我们也标注整个块为坏块。

    判断坏块程序:

    U8 rNF_IsBadBlock(U32 block)
    {
           return rNF_RamdomRead(block*64, 2054);
    }

    标记坏块程序:

    U8 rNF_MarkBadBlock(U32 block)
    {
        U8 result;
        result = rNF_RamdomWrite(block*64, 2054, 0x33);
        if(result == 0x44)
            return 0x21;                  //写坏块标注失败
        else
            return 0x60;                  //写坏块标注成功
    }
  • 相关阅读:
    day10 基本数据类型(下)
    day09 作业
    day09 基本数据类型(中)
    day08 作业
    day8 for循环+基本数据类型(上)
    Python正课109 —— 前端 进阶8
    Python正课108 —— 前端 进阶7
    Python正课107 —— 前端 进阶6
    Python正课106 —— 前端 进阶 5
    Python正课105 —— 前端 进阶4
  • 原文地址:https://www.cnblogs.com/zpehome/p/3239559.html
Copyright © 2020-2023  润新知