Mini2440裸机开发之Nand Flash 编程

#define  TACLS   0
#define  TWRPH0  1
#define  TWRPH1  0
/*设置Nand Flash的时序*/
NFCONF = (TACLS<<12) | (TWRPH0<<8) | (TWRPH1<<4);

/*使能Nand Flash控制器，禁止片选*/
NFCONT = (1<<1) | (1<<0);

① column:列地址A0~A10，就是页内地址，地址范围是从0到2047。（A11用来确定oob的地址，即2048-2111这64个字节的范围）
② page：A12～A28，称作页号，page(row)编号。

/* 等待NAND Flash就绪 */
void _nand_wait_idle(void)
{
    int i;
    while(!(NFSTAT & BUSY));
    for(i=0; i<10; i++);
}

int is_boot_from_nor_flash(void)
{
    volatile u32 *p = (volatile u32 )0x00;

    u32 val = *p;                      /* get value from address 0x00 */
    *p = 0x12345678;                /* write value to address 0x00 */

    /* 写成功, 对应nand启动 */
    if(*p == 0x12345678){
        *p = val;
        return 0;
    }

    return 1;
}

/*****************************************************************************************************************
 *
 *  FileName  : nand.h
 *  Function  : Nand Flash设置
 *  Author    : zy
 *              K9F2G08U0C   258M   28位地址
 *
 ****************************************************************************************************************/
#ifndef __NAND_H__
#define __NDND_H__

#include  "type.h"

#define GSTATUS1        (*(volatile u32 *)0x560000B0)
#define BUSY            1

/* page size 2048byte */
#define NAND_PAGE_SIZE           2048
#define NAND_PAGE_MASK_SIZE      (NAND_PAGE_SIZE - 1)
#define NAND_BLOCK_SIZE          (64*NAND_PAGE_SIZE)
#define NAND_BLOCK_MASK_SIZE     (NAND_BLOCK_SIZE-1)

/******************************************************************************************************************/
/* Nand Flash (see S3C2440 manual chapter 6, www.100ask.net) */
#define     NFCONF        (*(volatile u32 *)0x4e000000)        // 配置寄存器
#define     NFCONT       (*(volatile u32 *)0x4e000004)        // 控制寄存器
#define     NFCMMD       (*(volatile u8  *)0x4e000008)        // 命令寄存器
#define     NFADDR       (*(volatile u8  *)0x4e00000C)        // 地址寄存器
#define     NFDATA       (*(volatile u8  *)0x4e000010)        // 数据寄存器
#define     NFMECCD0     (*(volatile u32 *)0x4e000014)
#define     NFMECCD      (*(volatile u32 *)0x4e000018)
#define     NFSECCD      (*(volatile u32 *)0x4e00001C)
#define     NFSTAT       (*(volatile u32 *)0x4e000020)
#define     NFESTAT0     (*(volatile u32 *)0x4e000024)
#define     NFESTAT1     (*(volatile u32 *)0x4e000028)
#define     NFMECC0      (*(volatile u32 *)0x4e00002C)
#define     NFMECC1      (*(volatile u32 *)0x4e000030)
#define     NFSECC       (*(volatile u32 *)0x4e000034)
#define     NFSBLK       (*(volatile u32 *)0x4e000038)
#define     NFEBLK       (*(volatile u32 *)0x4e00003C)

/******************************************************************************************************************/
typedef struct {                                 /* 函数指针作为结构体成员 */
    /* 组成完整的命令操作的步骤 */
    void (*_nand_reset)(void);                         /* 初始化nand控制器 */
    void (*_nand_wait_idle)(void);                     /* 等待NAND Flash就绪 */
    void (*_nand_select_chip)(void);                   /* 使能片选 */
    void (*_nand_deselect_chip)(void);                 /* 禁止片选 */
    void (*_nand_write_cmd)(u32 cmd);                  /* 发命令 */
    void (*_nand_write_addr)(u32 addr);                /* 发地址 */
    u8 (*_nand_read_data)(void);                       /* 读数据 */

    /* 完整的命令操作 */
    int (*nand_read_data)(u8 *buf, u32 start_addr, u32 size);    /* 发送读取数据命令, start_addr参数必须按页对齐 success:0 fail:-1 */
    void (*nand_read_id)(u8 *buf);                               /* 读ID,buf length 5*/
    int  (*nand_block_erase)(u32 start_addr,u32 size);           /* 块擦除(block erase),参数必须按块对齐  success:0 fail:-1  */
    int (*nand_write_data)(u32 start_addr,u8 *buf, u32 size);    /* 发送写数据命令, start_addr参数必须按页对齐  success:0 fail:-1*/
}t_nand_chip;

/* 供外部调成员和方法 */
extern t_nand_chip nand_chip;                   /* nand_init执行后可以使用,extern全局变量避免重复定义 */
extern void nand_init(void);                    /* 初始化NAND Flash,给nand_chip函数指针成员赋值 */

#endif

/****************************************************************************************************/
#include "nand.h"

/* 全局变量 */
t_nand_chip nand_chip;
/****************************************************************************************************/
/* 等待NAND Flash就绪 */
void _nand_wait_idle(void)
{
    int i;
    while(!(NFSTAT & BUSY));
    for(i=0; i<10; i++);
}

/* 发出片选信号 */
void _nand_select_chip(void)
{
    int i;
    NFCONT &= ~(1<<1);                   /* set CE=0 */
    for(i=0; i<10; i++);    
}

/* 取消片选信号 */
void _nand_deselect_chip(void)
{
    NFCONT |= (1<<1);                   /* set CE=1 */
}

/* 发出命令 */
void _nand_write_cmd(u8 cmd)
{
    int i;
    NFCMMD = cmd;
    for(i=0; i<10; i++);
}

/* 发出地址 */
void _nand_write_addr_byte(u8 addr)
{
    volatile int i;
    NFADDR = addr;
    for(i=0; i<10; i++);
}

/* 发出地址,5个周期来发送，前2个周期为col地址，后三个周期为row(page)地址 */
void _nand_write_addr(u32 addr)
{
    int col, page;

    col = addr & NAND_PAGE_MASK_SIZE;
    page = addr / NAND_PAGE_SIZE;     /* 块号  */

    _nand_write_addr_byte(col & 0xff);            /* Column Address A0~A7 */
    _nand_write_addr_byte((col >> 8) & 0x0f);     /* Column Address A8~A11 */
    _nand_write_addr_byte(page & 0xff);            /* Row Address A12~A19 */
    _nand_write_addr_byte((page >> 8) & 0xff);    /* Row Address A20~A27 */
    _nand_write_addr_byte((page >> 16) & 0x01);    /* Row Address A28 */
}

/* 复位 */
void _nand_reset(void)
{
    _nand_select_chip();
    _nand_write_cmd(0xff);          // 复位命令
    _nand_wait_idle();
    _nand_deselect_chip();
}

/* 读取数据 */
u8 _nand_read_data(void)
{
    return NFDATA;
}

/* 写入数据 */
void _nand_write_data(u8 data)
{
    int i;
    NFDATA = data;
    for(i=0; i<10; i++);
}

/* Read ID */
void nand_read_id(u8 *buf)
{
    /* 选中芯片 */
    _nand_select_chip();

    /* write cmd 0x90 */
    _nand_write_cmd(0x90);

    /* write addr 0x00 */
    _nand_write_addr(0x00);

    /* read */
    buf[0] = _nand_read_data();    /* 第一个访问周期锁存的数据为marker code，值为0xEC */
    buf[1] = _nand_read_data();    /* 第二个访问周期的数据为device code，值为0xDA */
    buf[2] = _nand_read_data();    /* 0X10 */
    buf[3] = _nand_read_data();    /* 0X95*/
    buf[4] = _nand_read_data();    /* 0X44 */

    /* 取消片选信号 */
    _nand_deselect_chip();
}

/* 发送读取数据命令,start_addr参数必须按页对齐   success:0 fail:-1  */
int nand_read_data(u8 *buf, u32 start_addr, u32 size)
{
    int i = 0;
    int j = 0;

    if (start_addr & NAND_PAGE_MASK_SIZE ) {
        return -1;    /* 地址或长度不对齐 */
    }


    /* 选中芯片 */
    _nand_select_chip();

    /* 按页读取 */
    while (i < size) {
      /* 发出READ命令 */
      _nand_write_cmd(0);

      /* write address */
      _nand_write_addr(start_addr+i);

      /* write cmd */
      _nand_write_cmd(0x30);

      /* wait */
      _nand_wait_idle();

      /* 读取一页数据 */
      for(; (j < NAND_PAGE_SIZE) &&  (i < size); j++)
      {
          buf[i++] = _nand_read_data();
      }
      j = 0;
    }

    /* 取消片选信号 */
    _nand_deselect_chip();
    
    return 0;
}

/* 块擦除(block erase),参数必须按块对齐  success:0 fail:-1  */
int nand_block_erase(u32 start_addr,u32 size)
{
    int i;
    int page = start_addr / NAND_PAGE_SIZE;     /* 块号  */

    if ((start_addr & NAND_BLOCK_MASK_SIZE) || (size & NAND_BLOCK_MASK_SIZE)) {
        return -1;    /* 地址或长度不对齐 */
    }

    /* 选中芯片 */
    _nand_select_chip();

    for(i=start_addr; i < (start_addr + size);)
    {
        page = i / NAND_PAGE_SIZE;

        /* write cmd 0x60 */
        _nand_write_cmd(0x60);

        /* write row addr  */
        _nand_write_addr_byte(page & 0xff);            /* Row Address A12~A19 */
        _nand_write_addr_byte((page >> 8) & 0xff);    /* Row Address A20~A27 */
        _nand_write_addr_byte((page >> 16) & 0x01);    /* Row Address A28 */

        /* write cmd 0xD0 */
        _nand_write_cmd(0xD0);

        /* wait */
        _nand_wait_idle();

        /* write cmd 0x70 */
        _nand_write_cmd(0x70);

        if (_nand_read_data()&0x1)
        {
            return -1;
        }
        i += NAND_BLOCK_SIZE;
    }

    /* 取消片选信号 */
    _nand_deselect_chip();
    return 0;
}


/* 发送写数据命令, start_addr参数必须按页对齐  success:0 fail:-1*/
int nand_write_data(u32 start_addr,u8 *buf, u32 size)
{
    int i = 0;
    int j = 0;

    if (start_addr & NAND_PAGE_MASK_SIZE )
    {
        return -1;    /* 地址或长度不对齐 */
    }

    /* 选中芯片 */
    _nand_select_chip();

    /* 按页写 */
    while (i < size)
    {
      /* 发出WRITE命令 */
      _nand_write_cmd(0x80);

      /* write address */
      _nand_write_addr(start_addr + i);

      /* WRITE数据 */
      for(; (j < NAND_PAGE_SIZE) && (i<size); j++)
      {
          _nand_write_data(buf[i++]);
      }

      /* write cmd */
      _nand_write_cmd(0x10);

      /* wait */
      _nand_wait_idle();

      /* write cmd 0x70 */
      _nand_write_cmd(0x70);

      if (_nand_read_data()&0x1)
      {
          return -1;
      }

      j = 0;
    }

    /* 取消片选信号 */
    _nand_deselect_chip();

    return 0;
}

/* 初始化NAND Flash, 给nand_chip函数指针成员赋值*/
void nand_init(void)
{
    #define TACLS   0
    #define TWRPH0  1
    #define TWRPH1  0

    nand_chip._nand_reset          = _nand_reset;
    nand_chip._nand_wait_idle      = _nand_wait_idle;
    nand_chip._nand_select_chip    = _nand_select_chip;
    nand_chip._nand_deselect_chip  = _nand_deselect_chip;
    nand_chip._nand_write_cmd      = _nand_write_cmd;
    nand_chip._nand_write_addr     = _nand_write_addr;
    nand_chip._nand_read_data      = _nand_read_data;
    nand_chip.nand_read_data       = nand_read_data;
    nand_chip.nand_read_id         = nand_read_id;
    nand_chip.nand_block_erase     = nand_block_erase;
    nand_chip.nand_write_data      = nand_write_data;

    /* 设置时序 */
    NFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4);
    /* 使能NAND Flash控制器, 初始化ECC, 禁止片选, 使能NAND控制器 */
    NFCONT = (1<<4)|(1<<1)|(1<<0);

    /* 复位NAND Flash */
    _nand_reset();
}

#include "led.h"
#include "uart.h"
#include "printf.h"
#include "nand.h"
#include "init.h"

u32 get_uint()
{
    return NAND_BLOCK_SIZE*10;
}

void do_erase_nand_flash(void)
{
    unsigned int addr;

    /* 获得地址 */
    addr = get_uint();

    printf("erasing ...nr");
    if(nand_chip.nand_block_erase(addr, 128*1024) == 0)
    {
        printf("erasing successnr");
    }
}

void do_read_nand_flash(void)
{
    unsigned int addr;
    volatile u8 *p;
    int i, j;
    unsigned char buf[64];

    /* 获得地址 */
    addr = get_uint();

    printf("reading ...nr");
    nand_chip.nand_read_data(buf, addr, 64);
    p = (volatile u8 *)buf;

    printf("Data : nr");
    /* 长度固定为64 */
    for (i = 0; i < 4; i++)
    {
        /* 每行打印16个数据 */
        for (j = 0; j < 16; j++)
        {
            /* 先打印数值 */
            printf("%c ", *p++);
        }
        printf("nr");
    }
}

void do_write_nand_flash(void)
{
    unsigned int addr;
    u8 str[64];
    int i;
    unsigned int val;

    /* 获得地址 */
    addr = get_uint();

    for(i=0;i<64;i++)
    {
        str[i] = 'A' + i%26;
    }

    printf("writing ...nr");
    nand_chip.nand_write_data(addr,str, NAND_PAGE_SIZE);
}

void do_read_nand_id()
{
    unsigned char buf[5]={0};
    nand_chip.nand_read_id(buf);
    printf("maker   id  = 0x%xnr",buf[0]);      // 0xEC
    printf("device  id  = 0x%xnr",buf[1]);      // 0xDA
    printf("3rd byte    = 0x%xnr",buf[2]);      // 0x10
    printf("4th byte    = 0x%xnr",buf[3]);      // 0x95
    printf("page  size  = %d kbnr",1  <<  (buf[3] & 0x03));        // 2kb
    printf("block size  = %d kbnr",64 << ((buf[3] >> 4) & 0x03));  // 128kb
    printf("5th byte    = 0x%xnr",buf[4]);                         // 0x44
}

int main()
{
    led_init();
    
    // 串口初始化以及接收中断
    uart_init();
    
    nand_init();

    int flag = is_boot_from_nor_flash();

    do_write_nand_flash();
    do_read_nand_flash();
    do_erase_nand_flash();
    do_read_nand_id();
    if(flag){
        led_on(LED2);
    }
    while(1)
    {
        led_turn(LED1);
        delay_ms(4000);
  }
   return 0;
}