加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

NandFlash 控制器操作实例：读Flash

发布时间：2020-12-15 19:54:11 所属栏目：百科 来源：网络整理
导读：摘要: 本文以S3C2440为例来讲解NAND FLASH控制器的使用方法. 例程中故意将一部分代码放置到 nand 的4k 字节之后,因无法自动拷贝到steppingstone,所以需要读取nand中的内容到sdram。 代码执行示意图： nand.lds SECTIONS { firtst 0x00000000 : { head .o ini

摘要: 本文以S3C2440为例来讲解NAND FLASH控制器的使用方法. 例程中故意将一部分代码放置到 nand 的4k 字节之后,因无法自动拷贝到steppingstone,所以需要读取nand中的内容到sdram。

代码执行示意图：

这里写图片描述


这里写图片描述

nand.lds

SECTIONS { 
  firtst    0x00000000 : { head.o init.o nand.o}
  /*head.o、init.o和nand.o组成，加载地址和运行地址都是0，运行前不需要重新移动代码*/

  second    0x30000000 : AT(4096) { main.o }
   /*由main.o组成，运行地址为0x30000000,加载地址为4096(即偏移地址)，表明段second *存放在编译所得映象文件地址2048处，在运行前将它重定位到地址0x30000000处，*/
}

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,=4096 @设置堆栈 
 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 @1. 目标地址=0x30000000，这是SDRAM的起始地址
 mov r1,#4096 @2. 源地址 = 4096，连接的时候，main.c中的代码都存在NAND Flash地址4096开始处
 mov r2,#2048 @3. 复制长度= 2048(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   = 0;
}

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

    /* SDRAM 13个寄存器的值 */
    unsigned long  const    mem_cfg_val[]={ 0x22011110,//BWSCON
                                            0x00000700,//BANKCON0
                                            0x00000700,//BANKCON1
                                            0x00000700,//BANKCON2
                                            0x00000700,//BANKCON3 
                                            0x00000700,//BANKCON4
                                            0x00000700,//BANKCON5
                                            0x00018005,//BANKCON6
                                            0x00018005,//BANKCON7
                                            0x008C07A3,//REFRESH
                                            0x000000B1,//BANKSIZE
                                            0x00000030,//MRSRB6
                                            0x00000030,//MRSRB7
                                    };

    for(; i < 13; i++)
        p[i] = mem_cfg_val[i];
}

nand.c

#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,www.100ask.net) */
typedef struct {
    S3C24X0_REG32   NFCONF;
    S3C24X0_REG32   NFCONT;
    S3C24X0_REG32   NFCMD;
    S3C24X0_REG32   NFADDR;
    S3C24X0_REG32   NFDATA;
    S3C24X0_REG32   NFMECCD0;
    S3C24X0_REG32   NFMECCD1;
    S3C24X0_REG32   NFSECCD;
    S3C24X0_REG32   NFSTAT;
    S3C24X0_REG32   NFESTAT0;
    S3C24X0_REG32   NFESTAT1;
    S3C24X0_REG32   NFMECC0;
    S3C24X0_REG32   NFMECC1;
    S3C24X0_REG32   NFSECC;
    S3C24X0_REG32   NFSBLK;
    S3C24X0_REG32   NFEBLK;
} 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;

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(); // 等待nand就绪
    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=0; i<10; i++);
}

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

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

/* 发出命令 */
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=0; i<10; i++);
    *p = (addr >> 9) & 0xff;
    for(i=0; i<10; i++);
    *p = (addr >> 17) & 0xff;
    for(i=0; i<10; i++);
    *p = (addr >> 25) & 0xff;
    for(i=0; i<10; 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();    /// 等待nand就绪
    s3c2440_nand_deselect_chip();// 取消选中
}

/* 等待NAND Flash就绪 */
static void s3c2440_wait_idle(void)
{
    int i;
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFSTAT;//状态寄存器,只用到位0. 0 : busy 1 : ready
    while(!(*p & BUSY))
        for(i=0; i<10; i++);
}

/* 发出片选信号 */
static void s3c2440_nand_select_chip(void)
{
    int i;
    s3c2440nand->NFCONT &= ~(1<<1);
    for(i=0; i<10; i++);    
}

/* 取消片选信号 */
static void s3c2440_nand_deselect_chip(void)
{
    s3c2440nand->NFCONT |= (1<<1);
}

/* 发出命令 */
static void s3c2440_write_cmd(int cmd)
{
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFCMD;//NFCMD 不同的flash命令不一样,发送命令信号
    *p = cmd;
}

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

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

/* 发出地址(大页 5周期) */
static void s3c2440_write_addr_lp(unsigned int addr)
{
    int i;
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFADDR;//NFADDR当向该寄存器写入数据时,芯片向nand发送地址信号
    int col,page;
    //#define NAND_SECTOR_SIZE_LP 2048
    //#define NAND_BLOCK_MASK_LP (NAND_SECTOR_SIZE_LP - 1)
    col = addr & NAND_BLOCK_MASK_LP; //2048 -1 = 22222222221b,这里是屏蔽高位,取低11位数据,因为寻址空间只到 2k = 2^11,所以最多用11位,这里直接不考虑第12位
                                     //参考链接:http://bbs.csdn.net/topics/360034390
                                     //或者参考http://blog.csdn.net/czg13548930186/article/details/75043343 大页寻址方式
    page = addr / NAND_SECTOR_SIZE_LP;//2048 = 2^11,这里将数据右移11位,获取高位数据

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


/* 读取数据 */
static unsigned char s3c2440_read_data(void)
{
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFDATA;//数据寄存器,读写都是这个寄存器. 只用到它的低 8 位
    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=0; i<10; 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 */
    if ((GSTATUS1 == 0x32410000) || (GSTATUS1 == 0x32410002))
    {
        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 = (1<<15)|(1<<12)|(1<<11)|(TACLS<<8)|(TWRPH0<<4)|(TWRPH1<<0);
    }
    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<<12)|(TWRPH0<<8)|(TWRPH1<<4);
        /* 使能NAND Flash控制器,禁止片选 */
        s3c2440nand->NFCONT = (1<<4)|(1<<1)|(1<<0);
    }

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


/* 读函数 */
void nand_read(unsigned char *buf,int size)//在head.S中设置的r0 r1 r2 分别为该函数的三个参数
{
    int i,j;
//NAND Flash 每次读操作是以page为单位的，一个page在此是2048byte(不同的NAND Flash的page大小不一定相同)，
//因为2047的二进制表示是11个1， 即22222222221， 一个数如果是2048的倍数，低11bit必须是0， 即 ****00000000000
//所以把一个数跟2047按位与就可判断它是不是2048的倍数。
#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(0);

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

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

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

    return ;
/*总结一下：（1）选中芯片（2）发送00h（3）发出地址（4）发30h（5）等待就绪（6）读一页数据*/
}

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 > 0; dly--);
}

int main(void)
{
    unsigned long i = 0;

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

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

    return 0;
}

Makefile

objs := head.o init.o nand.o main.o
# $^ 代表所有的依赖文件。 $@--目标文件，$<--第一个依赖文件。
nand.bin : $(objs)
    arm-linux-ld -Tnand.lds -o nand_elf $^ 
    arm-linux-objcopy -O binary -S nand_elf $@  # binary：二进制的 -S：不从源文件复制重定位信息和符号信息到目标文件中去
    arm-linux-objdump -D -m arm  nand_elf > nand.dis # -D：反汇编所有段 -m arm:指定反汇编文件使用arm架构


%.o:%.c
    arm-linux-gcc -Wall -c -O2 -o $@ $<    #-Wall：打开警告信息 -O2：2级优化(常用) -c：只编译不连接

%.o:%.S
    arm-linux-gcc -Wall -c -O2 -o $@ $<

clean:
    rm -f  nand.dis nand.bin nand_elf *.o

按照代码分析顺序摆放代码，拿到裸机程序一般都先分析连接脚本！

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同