;自己写的NandFlash驱动内存冲突

自己写的NandFlash驱动内存冲突，nandread函数将读出的512b数据放在数组nand中。可以读出，但会把其他函数和断点覆盖。以下是所有代码，请高手指点。。。


        INCLUDE 2410addr.inc
       
        AREA  Init,CODE,READONLY            
        ENTRY                            

        import Main
       
        ldr r0,=WTCON                ;关看门狗
        ldr r1,=0x0
        str r1,[r0]
       
        ldr r0,=GPHCON                ;设置I/0                                ;一下设置串口
        ldr r1,=0xa0
        str r1,[r0]
        ldr r0,=GPHUP
        ldr r1,=0x0c
        str r1,[r0]
       
        ldr r0,=ULCON0                ;正常模式/无奇偶/每帧一位/每帧8-bits
        ldr r1,=0x03
        str r1,[r0]
       
        ldr r0,=UCON0                ;中断请求或表决模式/中断请求或表决模式
        ldr r1,=0x05
        str r1,[r0]
       
        ldr r0,=UFCON0                ;不使用FIFO
        ldr r1,=0x00
        str r1,[r0]
       
        ldr r0,=UMCON0                ;不使用流控制
        ldr r1,=0x00
        str r1,[r0]
       
        ldr r0,=UBRDIV0                ;设置波特率
        ldr r1,=0x0c
        str r1,[r0]
       
        ldr sp, =0x40000000        ;设置堆栈
       
        ldr r0,=BWSCON                ;设置内存       
        ldr r1,=0x22111110
        str r1,[r0]
       
        ldr r0,=BANKCON6
        ldr r1,=0x18005
        str r1,[r0]
        ldr r0,=BANKCON7
        str r1,[r0]
       
        ldr r0,=REFRESH
        ldr r1,=0x8e0000
        str r1,[r0]
       
        ldr r0,=BANKSIZE
        ldr r1,=0xb1
        str r1,[r0]
       
        ldr r0,=MRSRB6
        ldr r1,=0x30
        str r1,[r0]
        ldr r0,=MRSRB7
        STR R1,[R0]
       
        b Main
       
        end



#include "2410addr.h"

char int2char(unsigned int);        //声明int2char函数
void uart_send(char *c);                //声明发送函数
static char key=' ';
static unsigned int nand[200];                //定义从NandFlash读出的数据存放的数组
unsigned int n;       
void nandread(unsigned int);
void nanderase(unsigned int);
void out(void);
unsigned int e;

void Main(void)
{       
        rGPFCON=0x5555;                        //设置端口为输出        此部分应根据实际需要改动或去掉
        rGPFUP=0xffff;                        //断开上拉电阻
        rGPFDAT=0xffff;                        //输出0xffff(灯全灭）
        while(1)
        {
       
                rGPFDAT=~(1<<4);//LED
               
                nandread(0x00);    //读取nandflash
                out();              //输出

                rGPFDAT=~(1<<5);//LED
               
                nanderase(0x00);    //擦除nandflash
                nandread(0x00);      //再次读取nandflash
                out();             //输出
               
                rGPFDAT=~(1<<6);//LED
               
                while(1){}
        }
}

void nanderase(unsigned int a)
{
        rNFCONF=0xF830;               
        rNFCONF&=~0x800;                //使能NandFlash
        rNFCMD=0x60;
        rNFADDR=a&0xff;
        rNFADDR=(a>>8)&0xff;
        rNFADDR=(a>>16)&0xff;
        rNFCMD=0xd0;
        while((rNFSTAT&0x01)==0){}
}

void nandread(unsigned int dz)
{       
        unsigned int a,b,c,d;       

        rNFCONF=0xF830;               
        rNFCONF&=~0x800;                        //使能NandFlash
        rNFCMD=0x0ff;                                //复位命令
        while((rNFSTAT&0X1)==0){}                //等待NFSTAT位0==1
        rNFCMD=0x00;                                //读命令
        rNFADDR=dz&0xff;                                //以下写入地址
        rNFADDR=(dz>>9)&0xff;
        rNFADDR=(dz>>17)&0xff;
        rNFADDR=(dz>>25)&0xff;
        while((rNFSTAT&0X01)==0){}                //等待NFSTAT位0==1
        n=0;
        while(n!=128)
        {
                a=rNFDATA&0xff;                //连续读NFDATA寄存器512次，得到一页（512B）数据
                b=rNFDATA&0xff;
                c=rNFDATA&0xff;
                d=rNFDATA&0xff;
               
                nand[n]=a|(b<<8)|(c<<16)|(d<<24);
                n++;
        }
        rGPFDAT=~(1<<7);//LED
}

void out(void)
{
        n=0;
        while(n!=128)
        {       
                uart_send("\n");

                e=(nand[n]>>28)&0x0f;
                key=int2char(e);
                uart_send(&key);
               
                e=(nand[n]>>24)&0x0f;
                key=int2char(e);
                uart_send(&key);
       
                e=(nand[n]>>20)&0x0f;
                key=int2char(e);
                uart_send(&key);
               
                e=(nand[n]>>16)&0x0f;
                key=int2char(e);
                uart_send(&key);

                e=(nand[n]>>12)&0x0f;
                key=int2char(e);
                uart_send(&key);
       
                e=(nand[n]>>8)&0x0f;
                key=int2char(e);
                uart_send(&key);
       
                e=(nand[n]>>4)&0x0f;
                key=int2char(e);
                uart_send(&key);
       
                e=nand[n]&0x0f;
                key=int2char(e);
                uart_send(&key);       
               
                n++;
        }
       
        uart_send("\n END");
}

void uart_send(char *c)                //发送函数
{
    for (;*c!='\0';c++)
    {
        while(!(rUTRSTAT0&0x02)) ;     //不断查询，直到可以发送数据
        rUTXH0=*c ;                    //发送数据
    }
}

char int2char(unsigned int a)
{
        if(a==0)
                {
                return ('0');
                }
        else if(a==1)
                {
                return ('1');
                }
        else if(a==2)
                {
                return ('2');
                }
        else if(a==3)
                {
                return ('3');
                }
        else if(a==4)
                {
                return ('4');
                }
        else if(a==5)
                {
                return ('5');
                }
        else if(a==6)
                {
                return ('6');
                }
        else if(a==7)
                {
                return ('7');
                }
        else if(a==8)
                {
                return ('8');
                }
        else if(a==9)
                {
                return ('9');
                }
        else if(a==0x0a)
                {
                return ('a');
                }
        else if(a==0x0b)
                {
                return ('b');
                }
        else if(a==0x0c)
                {
                return ('c');
                }
        else if(a==0x0d)
                {
                return ('d');
                }
        else if(a==0x0e)
                {
                return ('e');
                }
        else
                {
                return ('f');
                }
}

如果你是从Nand Flash启动的话，你需要在程序前4K完成对内存和Nand Flash的初始化，然后把整个程序搬运到SDRAM中运行，否则会出现你只能使用4K SRAM的空间，然后出现你现在这样的情况。