Nand Flash编程

1.读芯片ID

1.1 读芯片ID时序

简化为4个步骤：

• 1.使能片选

• 2.写命令0x90

• 3.写地址0x00

• 4.读ID信息

  /* 识别NAND FLASH */
  void scan_nand_flash(void)
  {
   int i;
   //保存读取ID信息的数组
   unsigned char id_info[5] = {0};
  
   nand_enable_cs();//使能CS
   nand_write_cmd(0x90);
   nand_write_addr(0x00);
  
   for(i = 0;i < 5;i++){
       id_info[i] = nand_read_data();
   }
   nand_disable_cs();//禁止CS
  
   printf("Maker  Code: 0x%x\r\n",id_info[0]);
   printf("Device Code: 0x%x\r\n",id_info[1]);
   printf("3rd   cycle: 0x%x\n\r",id_info[2]);
   printf("Page   size: %d KB\n\r",1  << (id_info[3] & 0x03));//页大小与id_info[3]最低2位有关
   printf("Block  size: %d KB\n\r",64 << ((id_info[3] >> 4) & 0x03));//块大小与id_info[3]第4、5位有关
  
   printf("5th   cycle: 0x%x\n\r",id_info[4]);

  1.2 由ID数据获得芯片参数

  

• ID信息的第4字节为0x95
• 页大小与id_info[3]最低2位有关，可得页大小为：2KB
• 块大小与id_info[3]第4、5位有关，可得块大小为：128KB

注意：如果此时烧写到Nand Flash，并从Nand Flash启动程序是不会成功的，因为这个bin文件大小已经超过了4K，且现在还没有实现nand flash的读函数。

2.读数据

目标：实现从NAND FLASH中启动，重定位所有数据至SDRAM，并实现读取芯片ID数据

2.1 NAND内部结构分析

• OOB：out of bank（在bank之外）
  由上图可得：
• 1Page = 2KB + 64B
• 1Block = 64 * Pages = 128KB + 4KB
• 1Device = 2048 * Blocks = 256MB + 8MB

• OOB区的作用：因为nand的缺点是会发生“位反转”，为了解决这个问题，nand中的OOB区，用于校验数据区的数据是否发生错误，当有错误时，可以恢复数据。（其本身不存储数据）
• 因为OOB中并不存放数据，只是用于校验数据区是否发生错误，因此当CPU读取Nand Flash第2048个数据，该数据为 Page1中的第0个byte

2.2 地址序列与时序

• 由地址序列可以看出：发出地址信号共需5个周期，前2个周期发出列地址（Column Address），后3个周期发出行地址（Row Address）
• 地址线序列有一些位是没有用到的，其目的也是以后兼容更大芯片的nand falsh
  

Nand Flash内部结构展开大致如下：

2.3 读数据流程

• 1.发出片选信号
• 2.发出0x00命令
• 3.发送5个周期的地址（两个列地址，三个行地址（page））
• 4.再发送0x30命令
• 5.等待就绪
• 6.读数据
• 7.禁止片选

2.4 转换所读地址的列与页

将输入的地址addr转换为：

• 列地址（Col Address）
  • page是定位到哪一个页，col变量定位的就是在这个页的偏移量（在这个页上的第几列0~2047）
• 行地址（页）
  • 因为读取数据的时候是一次性读出一页，因此当给出地址addr之后，每一页的数据大小是2K，因此我们可以根据地址知道我们读取的数据是哪一个页

    int col  = addr % 2048;//列地址  addr &(2048-1); 

    int page = addr / 2048;//行地址（相当于页地址）

2.5 NAND等待就绪

• 当NFSATA[0] = 0时，表示正忙
• 当NFSATA[0] = 1时，表示就绪

  /* 等待NAND就绪 */
  void nand_wait_ready(void)
  {
    while(!(NFSTAT & 0x01));//当NFSATA[0] = 1时，表示就绪
  }

2.6 读取数据函数

/* NAND FLASH读取数据
 * param:读取的地址、存放的地址、读取的长度
 */
void read_nand_data(unsigned int addr,unsigned char *buf,unsigned int len)
{
    int i = 0;

    /*page是定位到哪一个页，col变量定位的就是在这个
     *页的偏移量（在这个页上的第几列0~2047）
     */
    int col  = addr % 2048;//列地址  addr &(2048-1); 

    /* 因为读取数据的时候是一次性读出一页，因此当给出
     * 地址addr之后，每一页的数据大小是2K，因此我们可以
     * 根据地址知道我们读取的数据是哪一个页
     */
    int page = addr / 2048;//行地址（相当于页地址）

    nand_enable_cs();//1.使能CS

    while(i < len){
        nand_write_cmd(0x00);       //2.发出0x00命令

        /* col addr */
        nand_write_addr(col & 0xFF);//3.发出地址
        nand_write_addr((col >> 8) & 0xFF);  

         /* row/page addr */
        nand_write_addr(page & 0xFF);
        nand_write_addr((page >>  8) & 0xFF);
        nand_write_addr((page >> 16) & 0xFF);    

        nand_write_cmd(0x30);//4.发出0x30命令

        nand_wait_ready(); //5.等待就绪
        /* for循环中有2个条件
         * 1.当读到页尾，但还是没有读完，说明需要读取下一页
         * 2.当已经读取指定字节数，则不再读取
         */     
        for(; (col < 2048) && (i < len); col++){//6.读数据
            buf[i++] = nand_read_data_byte();
        }
        if(i == len){
            break;
        }
        col = 0;
        page++;//指向下一页
    }
    nand_disable_cs(); //7.禁止CS
}

2.7 NAND重定位

从Nand Flash启动，此时片内SRAM的地址对应的就是CPU的0地址，如果从Nand Flash启动，2440硬件会把nand Flash前4K的数据复制到片内SRAM,如果Nand Flash上的程序大于4K,那后续数据就会丢失，相当于只重定位了前4K的代码。

如何解决上述问题：

• 1.前提：实现了NAND FLASH读取数据函数
• 2.代码烧写到NAND FLASH,并从NAND中启动
• 3.程序运行到重定位代码的位置判断一下，是从Nand Flash启动还是NOR Flash启动（通过往0地址写数据，因为Nand是支持读写的，所以读出的结果和写的结果一样，而NOR Flash不能像内存一样读写，因此读写的内容是不一致的）
• 4.如果从NOR Flash启动，直接使用简单的重定位代码就行，如果是Nand Flash启动，那就是用Nnad Flash的读函数进行代码的重定位。

---

首先判断从NorFlash or NandFlash中启动

/* 检查是否从NorFlash中启动
 * 方法：写0x12345678到0地址，在读取出来，如果得到0x12345678，表示0地址上的内容被修改，即为片内RAM，则为nand启动
 * 原因：原因：nor不能直接写入，写入需要发出一定格式的数据，才能写入
 * 返回0为nand启动，返回1为nor启动
*/
int isBootFromNorFlash(void)
{
    volatile unsigned int *p = (volatile unsigned int *)0;
    unsigned int val = *p;//暂存[0]上的数据
    *p = 0xdeadc0de;//dead code任意值
    if(0xdeadc0de == *p){
        /* 写成功，对应nand启动 */
        *p = val;//恢复原来的值
        return 0;
    }
    else{
        return 1;
    }
}

重定位代码

/*
 * 将除bss段的全部数据拷贝到sdram中
 * 传递形参，原地址src:_start  目标地址dest:__bss_start  长度len:__bss_start-_star
 */
void copy_to_sdram(void)
{
    /* 要从lds文件中获取__code_start、__bss_start
     * 然后从0地址把数据复制到__code_start
     */
    extern int __code_start,__bss_start; //声明外部变量

    volatile unsigned int *src  = (volatile unsigned int *)0; //flash中0地址 
    volatile unsigned int *dest = (volatile unsigned int *)&__code_start; //目标地址：sdram中的0x30000000地址
    volatile unsigned int *end  = (volatile unsigned int *)&__bss_start;  //结束地址：bss的起始地址

    int len = (int)&__bss_start - (int)&__code_start;//获取数据总长度

    if(isBootFromNorFlash()){//如果从Nor中启动
        while(dest < end){
            *dest++ = *src++; //拷贝
        }
    }
    else{//从Nand中启动,需要先初始化nand，然后重定位代码
        nand_init();
        //从 src 复制到 des ,总共复制len字节，也就是重定位的代码
        read_nand_data((unsigned int)src,(unsigned char *)dest,len);
    }
}

2.7 读数据测试

读取0地址后160bytes的数据，如果跟.bin文件前160字节数据相同，则读取成功，否则读取失败

/* 测试函数：读数nand上160bytes数据 
 */
void read_nand_flash(void)
{
    int i,j;
    unsigned int addr,hex_addr;
    unsigned char c,str[16],data[160];
    volatile unsigned char *p;

    /* 获得地址 */
    printf("*****Enter the address to read:");
    addr = get_uint();

    read_nand_data(addr,data,160);//获取到地址上的数据
    p = (volatile unsigned char *)data;//p指向data,用于打印data数据

    hex_addr = addr;//起始地址
    printf("Read Data:\r\n");
    printf("            00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n\r");
     /* 长度固定为160 bytes */    
    for(i = 0; i < 10; i++){
        printf("0x%08x  ",hex_addr);
        //每行打印16个16进制数
        for(j = 0; j < 16; j++){
            c = *p++;//读取16个
            str[j] = c;//保存字符
            //先打印数值
            printf("%02x ",c);
        }
        printf(" | ");
        //后打印字符
        for(j = 0; j < 16; j++){
            if(str[j] < 0x20 || str[j] > 0x7e){//不可视字符,打印‘.’
                printf(".");
            }
            else{
                printf("%c",str[j]);
            }
        }
        hex_addr+=16;//换行+16
        printf("\n\r");
    }

}

由上测试可知读取成功

3.擦除

3.1 擦除时序

• 1.发出片选信号
• 2.发出0x60命令
• 3.发送3个行地址（page）
• 4.再发送0xD0命令
• 5.等待就绪（等待擦除完成）
• 6.禁止片选

3.2 地址和参数合法性

• 由于按块来擦除（128KB），因此地址和参数都必须是128K的倍数

•   /* 检查参数合法性 */
    if(addr & (0x1FFFF)){ //128K
        printf("Err addr! Please enter an integral multiple of 128K\r\n");
        return -1;
    }
    if(len & (0x1FFFF)){ //128K
        printf("Err len! Please enter an integral multiple of 128K\r\n");
        return -1;
    }

3.3 擦除函数

/* NAND FLASH擦除数据
 * param:擦除的起始地址、擦除的长度(byte)
 * ret:失败-1，成功0
*/
int erase_nand_data(unsigned int addr,unsigned int len)
{
    int page = addr / 2048;//行地址

    /* 检查参数合法性 */
    if(addr & (0x1FFFF)){ //128K
        printf("Err addr! Please enter an integral multiple of 128K\r\n");
        return -1;
    }
    if(len & (0x1FFFF)){ //128K
        printf("Err len! Please enter an integral multiple of 128K\r\n");
        return -1;
    }
    /* 1.使能CS */
    nand_enable_cs();
    while(1)
    {
        page = addr / 2048;//行地址

        /* 2.发出0x60命令 */
        nand_write_cmd(0x60); 
        /* 3.发出地址row/page addr */
        nand_page(page);      
        /* 4.发出0xD0命令 */
        nand_write_cmd(0xD0); 
        /* 5.等待就绪(等待擦除完成) */
        nand_wait_ready();    

        len -= (128*1024);//长度减去一个block
        if(0 == len){
            break;
        }
        addr += (128*1024);//指向下一块
    } 
    /* 6.禁止CS */
    nand_disable_cs();
    return 0;
}

3.4 擦除数据测试

/* 擦除测试函数：固定擦除一个1block = 128K
*/
void erase_nand_flash(void)
{
    int addr;
    unsigned int whichblock;
    /* 获得第几个Block */
    printf("Enter the address of sector to erase: ");
    addr = get_uint();

    whichblock = addr / (128*1024);

    printf("***** block number : [ %d ]\r\n",whichblock);

    /* 提示擦除数据的范围 */
    printf("***** Erase range : 0x%08x - 0x%08x\n\r",addr,(addr+(128*1024)));
     printf("***** erase ...\r\n");

     if(erase_nand_data(addr,128*1024) == 0){//如果擦除成功
         printf("***** Erase finished!\r\n");
     }
     else{
         printf("***** Erase fail!\r\n");
     }
}

4.写数据

4.1 写数据时序

• 1.发出片选信号
• 2.发出0x80命令
• 3.发送5个周期的地址（两个列地址，三个行地址（page））
• 4.写入数据
• 5.再发送0x10命令
• 6.等待就绪（等待擦除完成）
• 7.禁止片选
  

4.2 写数据函数

/* NAND FLASH写入数据
 * param:写入的地址、数据指针、写入的长度
 */
void write_nand_data(unsigned int addr,unsigned char *buf,unsigned int len)
{
    int i = 0;
    int page = addr / 2048;
    int col = addr & (2048 - 1);
    /* 1.使能CS */
    nand_enable_cs();
    while(1){
        /* 2.发出0x80命令 */
        nand_write_cmd(0x80);
        /* 3.发出地址 */
        nand_col(col);
        nand_page(page);
        /* 4.写入数据*/
        for(; (col < 2048) && (i < len); ){
            nand_write_data_byte(buf[i++]);            
        }
        /* 5.发出0x10命令 */
        nand_write_cmd(0x10);
        /* 6.等待就绪(等待写入完成) */
        nand_wait_ready();
        if(i == len){
            break;
        }
        else{
            col = 0;
            page++;
        }

    }
    /* 7.禁止CS */
    nand_disable_cs();
}

4.3 写数据测试

此处注意：一般在烧写数据之前需要对数据进行擦除操作，除非原本的数据全f，否则都需要进行擦除，不然写入的数据会有问题。

void write_nand_flash(void)
{
    unsigned int addr;
    unsigned char str[50];
    unsigned int len;

    /* 获得第几个Block */
    printf("***** Enter addr to write: ");
    addr = get_uint();

    printf("***** Enter the string to write: ");
    gets(str);
    len = strlen(str) + 1;

    printf("***** write range : 0x%08x - 0x%08x\r\n",addr,(addr + len));
    printf("***** writing ...\r\n");

    write_nand_data(addr,str,strlen(str)+1);//strlen不包括结束符'\0'，因此需要+1
    printf("***** writing finished\r\n");
}

• 在0x100000地址写入“hello,world!”
  
• 读取数据
  

5.判断是否为坏块

通过读取OOB区的第0个字节（即第2048个字节）来判断，如果不是0xFF，为坏块，否则不是

/* 判断是否为坏块
 * ret:返回1为坏块，返回0不是
 */
int isNandBadBlock(unsigned int addr)
{
    unsigned int col = 2048;//读取OOB区第0个字节
    unsigned int page = addr / 2048;
    unsigned char val = 0;
    /* 1. 选中 */
    nand_enable_cs();
    /* 2. 发出读命令00h */
    nand_write_cmd(0x00);
    /* 3. 发出地址(分5步发出) */
    nand_col(col);
    nand_page(page);
    /* 4. 发出读命令30h */
    nand_write_cmd(0x30);
    /* 5. 判断状态,等待就绪 */
    nand_wait_ready();
    /* 6. 读数据 */
    val = nand_read_data_byte();
    /* 7. 取消选中 */    
    nand_disable_cs();

    if(val != 0xFF){
        return 1; /* 坏块 */
    }
    else{
        return 0;
    }
}

6.ECC

• ECC（Error Checking and Correction），是一种用于Nand的差错检测和修正算法。