四、NAND Flash

4.1 nand flash启动u-boot

　　nand flash 启动的时候，CPU 需要将 nand flash 中前面 4KB 的内容复制到 SRAM 中执行，然后将 NAND Flash 中的所有内容拷贝到 SDRAM中。

　　前4 KB 的拷贝 是硬件自动执行的。

4.1.1 地址空间

　　原理图如下：

　　

　　nand flash 只有数据总线，并没有像 SDRAM 一样有地址总线。这样就有两种寻址方式就不同。

　　SDRAM 或 网卡、片内4K内存 都是地址总线接到 2440 上，他们的地址都是 CPU可以看到的，都是CPU发出来的，这为 CPU 统一编址。

　　nand flash 上页存在地址空间（0~256 M），nand flash 上的 0 地址 和 CPU 上的 0地址是不同的。

　　nand flash 地址都是通过 数据总线来发送的。

　　JZ2440板子上用的是大页的 nand flash，大页是指一个页里面有 2K 字节，小页只有 512 字节。结构如下图：

　　

　　一页分为 2K 字节 + 64字节的OOB，一块的大小为 128K + 4K byte，128/2 = 64 页组成一块。

　　OOB 在大多数时候不参与编址。

4.1.2 nand flash 操作

　　CPU 先发出命令给 nandflash 要寻址，然后发送地址，然后再发送 读或写命令，在读或写数据。

　　nand flash  的命令如下图：

　　

　　nandflash 引脚功能

　　

• 从硬件上访问 NAND
  • 发出命令：CLE引脚，命令发送到数据总线上
  • 发出地址：ALE引脚，地址发送到数据总线上
  • 传输数据：R/W
• 2440 控制
  • 发出命令，寄存器 NFCMMD 寄存器
  • 发出地址，寄存器 NFADDR 寄存器
  • 读写数据，NFDATA
  • 状态，NFSTAT　　

　　读流程如下：（其他流程见 nand flash  的芯片手册的第三章）

　　

4.1.3 代码

　　nand.lds

 SECTIONS {
     // head.o init.o nand.o 存放在地址 0x0000 0000 处
   firtst      0x00000000 : { head.o init.o nand.o}
     // main.o 存放在地址 0x3000 0000 处  SDRAM
   second     0x30000000 : AT() { main.o }
 }

　　head.S

 @******************************************************************************
 @ File：head.s
 @ 功能：设置SDRAM，将程序复制到SDRAM，然后跳到SDRAM继续执行
 @******************************************************************************       

 .text
 .global _start
 _start:
                                             @函数disable_watch_dog, memsetup, init_nand, nand_read_ll在init.c中定义
             ldr     sp, =               @设置堆栈，栈指向SRAM顶端
             bl      disable_watch_dog       @关WATCH DOG
             bl      memsetup                @初始化SDRAM
             bl      nand_init               @初始化NAND Flash

                                             @将NAND Flash中地址4096开始的1024字节代码(main.c编译得到)复制到SDRAM中
                                             @nand_read_ll函数需要3个参数：
             ldr     r0,     =0x30000000     @. 目标地址=0x30000000，这是SDRAM的起始地址
             mov     r1,     #           @.  源地址   = ，连接的时候，main.c中的代码都存在NAND Flash地址4096开始处
             mov     r2,     #           @.  复制长度= (bytes)，对于本实验的main.c，这是足够了
             bl      nand_read               @调用C函数nand_read

             ldr     sp, =0x34000000         @设置栈
             ldr     lr, =halt_loop          @设置返回地址
             ldr     pc, =main               @b指令和bl指令只能前后跳转32M的范围，所以这里使用向pc赋值的方法进行跳转
 halt_loop:
             b       halt_loop

　　init.c

 /* WOTCH DOG register */
 #define     WTCON                (*(volatile unsigned long *)0x53000000)

 /* SDRAM regisers */
 #define     MEM_CTL_BASE        0x48000000

 void disable_watch_dog();
 void memsetup();

 /*上电后，WATCH DOG默认是开着的，要把它关掉 */
 void disable_watch_dog()
 {
     WTCON    = ;
 }

 /* 设置控制SDRAM的13个寄存器 */
 void memsetup()
 {
     int     i = ;
     unsigned long *p = (unsigned long *)MEM_CTL_BASE;

     /* SDRAM 13个寄存器的值 */
     unsigned long  const    mem_cfg_val[]={ 0x22011110,     //BWSCON，这里将所有的内存配置都设置了，我们关注SDRAM DW6 0010 即可，为16位
                                             0x00000700,     //BANKCON0，
                                             0x00000700,     //BANKCON1
                                             0x00000700,     //BANKCON2
                                             0x00000700,     //BANKCON3
                                             0x00000700,     //BANKCON4
                                             0x00000700,     //BANKCON5
                                             0x00018005,     //BANKCON6，SDRAM 的设置，对照寄存器查看参数
                                             0x00018005,     //BANKCON7
                                             0x008C07A3,     //REFRESH，刷新寄存器，使能，刷新模式为自刷新，RAS改变时间为2个时钟，
                                                             //SDRAM Semi Row cycle time 为7个时钟
                                                             //Refresh Counte 为 11 1010 0011 = 931，Refresh period = (211-refresh_count+1)/HCLK
                                             0x000000B1,     //BANKSIZE,SDRAM 大小设置为 64M
                                             0x00000030,     //MRSRB6，SDRAM 模式设置
                                             0x00000030,     //MRSRB7
                                     };

     for(; i < ; i++)
         p[i] = mem_cfg_val[i];  // 为每一个 内存控制器的寄存器设置参数
 }

　　nand,c

 /* nand flash support S3C2410 and S3C2440 */

 #define LARGER_NAND_PAGE

 #define GSTATUS1        (*(volatile unsigned int *)0x560000B0)
 #define BUSY            1

 #define NAND_SECTOR_SIZE    512
 #define NAND_BLOCK_MASK     (NAND_SECTOR_SIZE - 1)

 #define NAND_SECTOR_SIZE_LP    2048
 #define NAND_BLOCK_MASK_LP     (NAND_SECTOR_SIZE_LP - 1)    //

 typedef unsigned int S3C24X0_REG32;

 /* NAND FLASH (see S3C2410 manual chapter 6) */
 typedef struct {
     S3C24X0_REG32   NFCONF;
     S3C24X0_REG32   NFCMD;
     S3C24X0_REG32   NFADDR;
     S3C24X0_REG32   NFDATA;
     S3C24X0_REG32   NFSTAT;
     S3C24X0_REG32   NFECC;
 } S3C2410_NAND;

 /* NAND FLASH (see S3C2440 manual chapter 6) */
 typedef struct {
     S3C24X0_REG32   NFCONF;     // nand flash 控制寄存器
     S3C24X0_REG32   NFCONT;     // nand flash 配置寄存器
     S3C24X0_REG32   NFCMD;      // nand flash 命令寄存器
     S3C24X0_REG32   NFADDR;     // nand flash 地址寄存器
     S3C24X0_REG32   NFDATA;     // nand flash 数据寄存器
     S3C24X0_REG32   NFMECCD0;   // nand flash ECC0/1寄存器
     S3C24X0_REG32   NFMECCD1;   // nand flash ECC2/3寄存器
     S3C24X0_REG32   NFSECCD;    // nand flash ECC寄存器
     S3C24X0_REG32   NFSTAT;     // nand flash 工作状态寄存器
     S3C24X0_REG32   NFESTAT0;   // nand flash IO[7:0]状态寄存器
     S3C24X0_REG32   NFESTAT1;   // nand flash IO[15:8]状态寄存器
     S3C24X0_REG32   NFMECC0;    // nand flash ECC0寄存器
     S3C24X0_REG32   NFMECC1;    // nand flash ECC1寄存器
     S3C24X0_REG32   NFSECC;     // nand flash ECC寄存器
     S3C24X0_REG32   NFSBLK;     // nand flash 块开始地址寄存器
     S3C24X0_REG32   NFEBLK;     // nand flash 块结束地址寄存器
 } S3C2440_NAND;

 typedef struct {
     void (*nand_reset)(void);
     void (*wait_idle)(void);
     void (*nand_select_chip)(void);
     void (*nand_deselect_chip)(void);
     void (*write_cmd)(int cmd);
     void (*write_addr)(unsigned int addr);
     unsigned char (*read_data)(void);
 }t_nand_chip;

 // 设置 nand 基地址
 static S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;
 static S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;

 static t_nand_chip nand_chip;

 /* 供外部调用的函数 */
 void nand_init(void);
 void nand_read(unsigned char *buf, unsigned long start_addr, int size);

 /* NAND Flash操作的总入口, 它们将调用S3C2410或S3C2440的相应函数 */
 static void nand_reset(void);
 static void wait_idle(void);
 static void nand_select_chip(void);
 static void nand_deselect_chip(void);
 static void write_cmd(int cmd);
 static void write_addr(unsigned int addr);
 static unsigned char read_data(void);

 /* S3C2410的NAND Flash处理函数 */
 static void s3c2410_nand_reset(void);
 static void s3c2410_wait_idle(void);
 static void s3c2410_nand_select_chip(void);
 static void s3c2410_nand_deselect_chip(void);
 static void s3c2410_write_cmd(int cmd);
 static void s3c2410_write_addr(unsigned int addr);
 static unsigned char s3c2410_read_data();

 /* S3C2440的NAND Flash处理函数 */
 static void s3c2440_nand_reset(void);
 static void s3c2440_wait_idle(void);
 static void s3c2440_nand_select_chip(void);
 static void s3c2440_nand_deselect_chip(void);
 static void s3c2440_write_cmd(int cmd);
 static void s3c2440_write_addr(unsigned int addr);
 static unsigned char s3c2440_read_data(void);

 /* S3C2410的NAND Flash操作函数 */

 /* 复位 */
 static void s3c2410_nand_reset(void)
 {
     s3c2410_nand_select_chip();
     s3c2410_write_cmd(0xff);  // 复位命令
     s3c2410_wait_idle();
     s3c2410_nand_deselect_chip();
 }

 /* 等待NAND Flash就绪 */
 static void s3c2410_wait_idle(void)
 {
     int i;
     volatile unsigned char *p = (volatile unsigned char *)&s3c2410nand->NFSTAT;
     while(!(*p & BUSY))
         for(i=; i<; i++);
 }

 /* 发出片选信号 */
 static void s3c2410_nand_select_chip(void)
 {
     int i;
     s3c2410nand->NFCONF &= ~(<<);
     for(i=; i<; i++);
 }

 /* 取消片选信号 */
 static void s3c2410_nand_deselect_chip(void)
 {
     s3c2410nand->NFCONF |= (<<);
 }

 /* 发出命令 */
 static void s3c2410_write_cmd(int cmd)
 {
     volatile unsigned char *p = (volatile unsigned char *)&s3c2410nand->NFCMD;
     *p = cmd;
 }

 /* 发出地址 */
 static void s3c2410_write_addr(unsigned int addr)
 {
     int i;
     volatile unsigned char *p = (volatile unsigned char *)&s3c2410nand->NFADDR;

     *p = addr & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
 }

 /* 读取数据 */
 static unsigned char s3c2410_read_data(void)
 {
     volatile unsigned char *p = (volatile unsigned char *)&s3c2410nand->NFDATA;
     return *p;
 }

 /* S3C2440的NAND Flash操作函数 */

 /* 复位 */
 static void s3c2440_nand_reset(void)
 {
     s3c2440_nand_select_chip();
     s3c2440_write_cmd(0xff);  // 发送复位命令
     s3c2440_wait_idle();
     s3c2440_nand_deselect_chip();
 }

 /* 等待NAND Flash就绪 */
 static void s3c2440_wait_idle(void)
 {
     int i;
     volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFSTAT;
     while(!(*p & BUSY)) //BUSY = 1，NFSTAT的 bit0 = 1 时候，为就绪，则跳出循环准备操作
         for(i=; i<; i++);
 }

 /* 发出片选信号 */
 static void s3c2440_nand_select_chip(void)
 {
     int i;
     s3c2440nand->NFCONT &= ~(<<);//将 nFCE 强制拉低，使能片选
     for(i=; i<; i++);//延迟
 }

 /* 取消片选信号 */
 static void s3c2440_nand_deselect_chip(void)
 {
     s3c2440nand->NFCONT |= (<<);//将 nFCE 强制拉高，不使能片选
 }

 /* 发出命令 */
 static void s3c2440_write_cmd(int cmd)
 {
     // 获取  NFCMD 的地址，对NFCMD的地址进行强转
     volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFCMD;
     *p = cmd;
 }

 /* 发出地址 */
 static void s3c2440_write_addr(unsigned int addr)
 {
     int i;
     volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFADDR;

     *p = addr & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
     *p = (addr >> ) & 0xff;
     for(i=; i<; i++);
 }

 static void s3c2440_write_addr_lp(unsigned int addr)
 {
     int i;
     volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFADDR;
     int col, page;

     col = addr & NAND_BLOCK_MASK_LP;
     page = addr / NAND_SECTOR_SIZE_LP;

     *p = col & 0xff;            /* Column Address A0~A7 */
     for(i=; i<; i++);
     *p = (col >> ) & 0x0f;     /* Column Address A8~A11 */
     for(i=; i<; i++);
     *p = page & 0xff;            /* Row Address A12~A19 */
     for(i=; i<; i++);
     *p = (page >> ) & 0xff;    /* Row Address A20~A27 */
     for(i=; i<; i++);
     *p = (page >> ) & 0x03;    /* Row Address A28~A29 */
     for(i=; i<; i++);
 }

 /* 读取数据 */
 static unsigned char s3c2440_read_data(void)
 {
     volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFDATA;
     return *p;
 }

 /* 在第一次使用NAND Flash前，复位一下NAND Flash */
 static void nand_reset(void)
 {
     nand_chip.nand_reset();
 }

 static void wait_idle(void)
 {
     nand_chip.wait_idle();
 }

 static void nand_select_chip(void)
 {
     int i;
     nand_chip.nand_select_chip();
     for(i=; i<; i++);
 }

 static void nand_deselect_chip(void)
 {
     nand_chip.nand_deselect_chip();
 }

 static void write_cmd(int cmd)
 {
     nand_chip.write_cmd(cmd);
 }
 static void write_addr(unsigned int addr)
 {
     nand_chip.write_addr(addr);
 }

 static unsigned char read_data(void)
 {
     return nand_chip.read_data();
 }

 /* 初始化NAND Flash */
 void nand_init(void)
 {
 #define TACLS   0
 #define TWRPH0  3
 #define TWRPH1  0

     /* 判断是S3C2410还是S3C2440 */
     /* GSTATUS1：通用状态寄存器，GSTATUS1 为读寄存器，是用来读出 chip ID,这是用来定位我们的设备的 */
     /* 所用的设备为 S3C2440AL，设备ID为 0x32440001 */
     if ((GSTATUS1 == 0x32410000) || (GSTATUS1 == 0x32440001))
     {
         nand_chip.nand_reset         = s3c2410_nand_reset;
         nand_chip.wait_idle          = s3c2410_wait_idle;
         nand_chip.nand_select_chip   = s3c2410_nand_select_chip;
         nand_chip.nand_deselect_chip = s3c2410_nand_deselect_chip;
         nand_chip.write_cmd          = s3c2410_write_cmd;
         nand_chip.write_addr         = s3c2410_write_addr;
         nand_chip.read_data          = s3c2410_read_data;

         /* 使能NAND Flash控制器, 初始化ECC, 禁止片选, 设置时序 */
         s3c2410nand->NFCONF = (<<)|(<<)|(<<)|(TACLS<<)|(TWRPH0<<)|(TWRPH1<<);
     }
     else
     {
         nand_chip.nand_reset         = s3c2440_nand_reset;
         nand_chip.wait_idle          = s3c2440_wait_idle;
         nand_chip.nand_select_chip   = s3c2440_nand_select_chip;
         nand_chip.nand_deselect_chip = s3c2440_nand_deselect_chip;
         nand_chip.write_cmd          = s3c2440_write_cmd;
 #ifdef LARGER_NAND_PAGE
         nand_chip.write_addr         = s3c2440_write_addr_lp;
 #else
         nand_chip.write_addr         = s3c2440_write_addr;
 #endif
         nand_chip.read_data          = s3c2440_read_data;

         /* 设置时序 */
         s3c2440nand->NFCONF = (TACLS<<)|(TWRPH0<<)|(TWRPH1<<);
         /* 使能NAND Flash控制器, 初始化ECC, 禁止片选 */
         s3c2440nand->NFCONT = (<<)|(<<)|(<<);
     }

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

 /* 读函数 */
 /* buf = 0x30000000, start_addr = 4096，size = 2048 */
 void nand_read(unsigned char *buf, unsigned long start_addr, int size)
 {
     int i, j;

 #ifdef LARGER_NAND_PAGE
     if ((start_addr & NAND_BLOCK_MASK_LP) || (size & NAND_BLOCK_MASK_LP)) {
         return ;    /* 地址或长度不对齐 */
     }
 #else
     if ((start_addr & NAND_BLOCK_MASK) || (size & NAND_BLOCK_MASK)) {
         return ;    /* 地址或长度不对齐 */
     }
 #endif    

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

     for(i=start_addr; i < (start_addr + size);) {
       /* 发出READ0命令 */
       write_cmd();

       /* Write Address */
       write_addr(i);
 #ifdef LARGER_NAND_PAGE
       write_cmd(0x30);
 #endif
       wait_idle();

 #ifdef LARGER_NAND_PAGE
       for(j=; j < NAND_SECTOR_SIZE_LP; j++, i++) {
 #else
       for(j=; j < NAND_SECTOR_SIZE; j++, i++) {
 #endif
           *buf = read_data();
           buf++;
       }
     }

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

     return ;
 }

　　main.c

 #define    GPFCON        (*(volatile unsigned long *)0x56000050)
 #define    GPFDAT        (*(volatile unsigned long *)0x56000054)

 #define    GPF4_out    (1<<(4*2))
 #define    GPF5_out    (1<<(5*2))
 #define    GPF6_out    (1<<(6*2))

 void  wait(volatile unsigned long dly)
 {
     for(; dly > ; dly--);
 }

 int main(void)
 {
     unsigned long i = ;

     GPFCON = GPF4_out|GPF5_out|GPF6_out;        // 将LED1-3对应的GPF4/5/6三个引脚设为输出

     while(){
         wait();
         GPFDAT = (~(i<<));         // 根据i的值，点亮LED1-3
         if(++i == )
             i = ;
     }

     return ;
 }