在嵌入式设计中，由于Nand Flash具有大容量，擦写次数高，接口简单等优点，常用作固化存储器。S3C2416支持Nand启动，因此Nand存储器可以直接保存固化代码以及其它的数据。笔者在此简单的介绍Nand flash驱动的实现以及Nand启动。

1. Nand驱动实现

笔者采用Nand flash为K9F2G08U0B，一页有(2048+64)Byte，一个block有64页，容量大小为(256M+8M)Byte，是一款8位宽的SLC flash。

1.1. Nand模块头文件

S3C2416 Nand控制器需要通过一些命令来访问Nand flash，并且需要实现底层的寄存器访问。在模块头文件中，我们定义Nand访问常用的命令(来自uboot命名)以及一些寄存器操作宏，并引出模块的接口函数，其内容如下：

#ifndef__NAND_H__
#define__NAND_H__
#ifdef__cplusplus
extern"C" {
#endif
// Nand flash5字节ID
typedefstruct Nand_ID_Info {
    unsigned char Maker;
    unsigned char Device;
    unsigned char ID_Data3;
    unsigned char ID_Data4;
    unsigned char ID_Data5;
}Nand_ID_Info;
/*
 * Standard NAND flash commands
 */
// 页读周期1(命令1)
#defineNAND_CMD_READ0      0
// 页读周期1(命令2)
#defineNAND_CMD_READ1      1
// 随机地址读周期1
#defineNAND_CMD_RNDOUT     5
// 页写周期2
#defineNAND_CMD_PAGEPROG   0x10
// OOB区读命令
#defineNAND_CMD_READOOB    0x50
// 块擦除命令周期1
#defineNAND_CMD_ERASE1     0x60
// 读Nand状态命令
#defineNAND_CMD_STATUS     0x70
// 读多层状态命令
#defineNAND_CMD_STATUS_MULTI   0x71
// 页写周期1
#defineNAND_CMD_SEQIN      0x80
// 随机地址写命令
#defineNAND_CMD_RNDIN      0x85
// 读ID命令
#defineNAND_CMD_READID     0x90
// 块擦除命令周期2
#define NAND_CMD_ERASE2    0xd0
// Nand复位
#defineNAND_CMD_RESET      0xff
/* Extendedcommands for large page devices */
// 页读周期2
#defineNAND_CMD_READSTART      0x30
// 随机地址读周期2
#defineNAND_CMD_RNDOUTSTART    0xE0
#defineNAND_CMD_CACHEDPROG 0x15
// 发送命令
#defineNF_CMD(Data)         {rNFCMD  = (Data);}
// 写地址
#defineNF_ADDR(Addr)        {rNFADDR = (Addr);}
// 读字(4字节)
#defineNF_READ_WORD()       (rNFDATA)
// 读一字节
#defineNF_READ_BYTE()       (rNFDATA8)
// 写字(4字节)
#defineNF_WRITE_WORD(Data)  {rNFDATA = (Data);}
// 写一字节
#defineNF_WRITE_BYTE(Data)  {rNFDATA8 = (Data);}
// 使能片选
#defineNF_CE_ENABLE()       {rNFCONT &=~(1<<1);}
// 关闭片选
#defineNF_CE_DISABLE()      {rNFCONT |=(1<<1);}
// 清空spare区ECC校验值
#defineNF_INIT_SECC()       {rNFCONT |= (1<<4);}
// 清空main区ECC校验值
#defineNF_INIT_MECC()       {rNFCONT |= (1<<5);}
// 解锁spare区ECC校验值
#defineNF_SECC_UNLOCK()     {rNFCONT &=~(1<<6);}
// 锁定spare区ECC校验值
#defineNF_SECC_LOCK()       {rNFCONT |= (1<<6);}
// 解锁main区ECC校验值
#defineNF_MECC_UNLOCK()     {rNFCONT &=~(1<<7);}
// 锁定main区ECC校验值
#defineNF_MECC_LOCK()       {rNFCONT |= (1<<7);}
// nand传输完会置位NFSTAT[4],若开启中断,会同时发送中断请求
#defineNF_WAIT_READY()      {while(!(rNFSTAT& (1<<4)));}
// 获得nand RnB引脚状态,1为准备好,0为忙
#defineNF_GET_STATE_RB()    {(rNFSTAT &(1<<0))}
// 清除nand传输完标志
#defineNF_CLEAR_RB()        {rNFSTAT |=(1<<4);}
/* 模块接口函数 */
externunsigned char Nand_ReadSkipBad(unsigned int Address, unsigned char *Buffer, unsignedint Length);
externunsigned char Nand_WriteSkipBad(unsigned int Address, unsigned char *Buffer, unsignedint Length);
extern voidNand_Init(void);
extern intNand_ReadID(Nand_ID_Info *pInfo);
externunsigned char Nand_EraseBlock(unsigned int Block);
externunsigned char Nand_MarkBadBlock(unsigned int Block);
externunsigned char Nand_IsBadBlock(unsigned int Block);
externunsigned char WriteCodeToNand(void); // 代码固化进Nand接口函数
#ifdef__cplusplus
}
#endif
#endif/*__NAND_H__*/

1.2. Nand初始化

对于不同的Nand flash，其时序要求不一样。为了达到最佳的性能，是要根据芯片手册设定一下Nand的访问时序参数的。Nand初始化函数如下：

//复位
static void Nand_Reset()
{
    NF_CE_ENABLE();
    NF_CLEAR_RB(); 
    NF_CMD(NAND_CMD_RESET);
    NF_WAIT_READY();   
    NF_CE_DISABLE();   
}
//初始化 
void Nand_Init()
{
    // 配置nand控制引脚
    rGPACON = (rGPACON &~(0x3f<<17)) |(0x3f<<17); 
    // 配置K9F2G08U0Btiming(HCLK@133M)
    // TACLS=1, (tALS或tCLS-tWP=0)(ALE或CLE有效后需保持才能发出写脉冲)
    // TWRPH0=2,tWP=12ns(最小写脉冲宽度)
    // TWRPH1=1,tALH或tCLH=5ns(写脉冲后ALE或CLE需保持有效时间)
    // SLC nand 1位检验就行,1-bit ECC
    rNFCONF =(1<<12)|(2<<8)|(1<<4)|(0<<0);
    // 上升沿检查nand准备好信号线
    rNFCONT =(0<<12)|(0<<10)|(0<<9)|(0<<8)
                |(0x3<<6)|(0x3<<4)|(0x3<<1)|(1<<0);
    Nand_Reset();
}

1.3 Nand ID的读取

Nand写入读ID命令(0x90)后，即可读取5字节的ID信息，ID信息包含了生产厂商，设备ID，以及nand页大小，块大小，位宽等重要信息。其函数实现如下：

intNand_ReadID(Nand_ID_Info *pInfo)
{
    if (pInfo == (Nand_ID_Info *)0) 
    {
        return 1; // 参数错误
    }
    NF_CE_ENABLE();
    NF_CLEAR_RB();
    NF_CMD(NAND_CMD_READID); // 发送读ID命令
    NF_ADDR(0x0); // 写0x0地址
    pInfo->Maker = NF_READ_BYTE(); //Maker:0xEC
    pInfo->Device = NF_READ_BYTE(); //Device:0xDA
    pInfo->ID_Data3 = NF_READ_BYTE(); //0x10
    pInfo->ID_Data4 = NF_READ_BYTE(); //0x95
    pInfo->ID_Data5 = NF_READ_BYTE();  //0x44  
    NF_CE_DISABLE();
    return 0;
}

1.4 Nand页读

K9F2G08U0B一页分为2k的main区与64字节的spare区，main区用来存储正常数据，spare区用来存储附加数据(如ECC检验)。对于flash存储器，是会出现位反转或坏块的问题，写入flash的数据或从flash读出的数据可能是有错的，因此必须用ECC进行校验，确保写入的数据与读出的数据是一致的。对于SLCNand Flash，只需1位ECC校验即可，而S3C2416能够产生硬件ECC，可产生4字节的main区ECC与2字节的spare区ECC。我们把4字节的main区ECC放在spare区0～3偏移地址处，2字节的sapre区ECC放在spare区4~5偏移地址处。页读函数如下：

// Block为Nand块区号，Page为对应块中的页号，Buffer为数据缓存区
static intNand_ReadPage(unsigned int Block, unsigned int Page,
                            unsigned char*Buffer)
{
    unsigned int i;
    unsigned int MECC, SECC;
    if (Buffer == (unsigned char *)0) {
        return 1; // 缓冲区为空，参数错误
    }
    Page &= (64-1); // 64 pagein one block
    Page += (Block << 6); //Block转换为页数
    NF_INIT_MECC(); // main区ECC清空
    NF_INIT_SECC(); // spare区ECC清空
    NF_MECC_UNLOCK(); // main区ECC解锁，开始ECC计算
    NF_CE_ENABLE(); // 使能片选
    NF_CLEAR_RB(); // 清数据传输标志
    NF_CMD(NAND_CMD_READ0);// page read cycle 1
    NF_ADDR(0); // column address
    NF_ADDR(0); // columu address
    NF_ADDR(Page & 0xff); // 写入3字节的页地址
    NF_ADDR((Page>>8) & 0xff);
    NF_ADDR((Page>>16) & 0xff);
    NF_CMD(NAND_CMD_READSTART); // page readcycle 2
    NF_WAIT_READY(); // 等待命令完成   
    for (i=0; i<2048; i++) { // 读取main区数据
        Buffer[i] = NF_READ_BYTE();
    }
    NF_MECC_LOCK(); // 锁定main ECC
    NF_SECC_UNLOCK(); // 解锁spare ECC
    MECC = NF_READ_WORD(); // spare区前4字节为main区ECC
    // main区的ECC放入到NFMECCD0/1中相应的位中
    rNFMECCD0=((MECC&0xff00)<<8) |(MECC&0xff);
    rNFMECCD1=((MECC&0xff000000)>>8) |((MECC&0xff0000)>>16);
    NF_SECC_LOCK(); // 锁定spare ECC
    // spare区第5,6这两字节为spare区ECC,剩下部分未使用
    SECC = NF_READ_WORD();
    // spare区的ECC放入到NFMECCD0/1中相应的位中
    rNFSECCD=((SECC&0xff00)<<8)|(SECC&0xff);   
    NF_CE_DISABLE();
    // check whether spare/main area bit failerror occurred
    if ((rNFECCERR0 & 0xf) == 0) {
        return 0; // 数据读取正确
    } else {
        return 2; // ECC检验不一致，数据读取有误
    }
}

1.5 Nand页写

当要写数据到一个Nand block时，要先确保这个块已经被擦除，并且需要跳过一些坏块。数据写完后，为确保写入与读取的数据一致，应同时写入数据的ECC校验值到spare区约定好的ECC位置。页写函数如下：

// Block为Nand块区号，Page为对应块中的页号，Buffer为数据缓存区
static intNand_WritePage(unsigned int Block, unsigned int Page,
                            unsigned char*Buffer)
{
    unsigned int i;
    unsigned char State;
    unsigned int MECC, SECC;
    if (Buffer == (unsigned char *)0) {
        return 1; // 数据缓存参数错误
    }
    if (Nand_IsBadBlock(Block)) {
        return 2; // 是坏块，返回坏块错误码
    }
    Page &= (64-1); // 1 block最大64页
    Page += (Block << 6); // block转换成页
    NF_INIT_MECC(); // main区ECC清空
    NF_INIT_SECC(); // spare区ECC清空
    NF_MECC_UNLOCK(); // main区ECC解锁，开始ECC计算
    NF_CE_ENABLE(); // 使能片选
    NF_CLEAR_RB(); // 清数据传输标志
    NF_CMD(NAND_CMD_SEQIN); // page programcycle 1
    NF_ADDR(0); // column address
    NF_ADDR(0); // columu address
    NF_ADDR(Page & 0xff); // 写入3字节页地址
    NF_ADDR((Page>>8) & 0xff);
    NF_ADDR((Page>>16) & 0xff);
    for (i=0; i<2048; i++) { // 写入2k数据到main区
        NF_WRITE_BYTE(Buffer[i]);      
    }
    NF_MECC_LOCK(); // 锁定main ECC
    MECC = rNFMECC0; // 4字节写main区数据的ECC 
    NF_SECC_UNLOCK(); // 解锁spare ECC
    NF_WRITE_BYTE(MECC&0xff);// 写4字节main ECC到spare区
    NF_WRITE_BYTE((MECC>>8) & 0xff);   
    NF_WRITE_BYTE((MECC>>16) & 0xff);  
    NF_WRITE_BYTE((MECC>>24) & 0xff);
    NF_SECC_LOCK(); // 锁定spare ECC
    SECC = rNFSECC; // 2字节的spare写数据ECC
    NF_WRITE_BYTE(SECC & 0xff); // 继续写入SECC
    NF_WRITE_BYTE((SECC>>8) & 0xff);
    NF_CMD(NAND_CMD_PAGEPROG); // page programcycle 2
    NF_WAIT_READY(); // 等待写完
    NF_CMD(NAND_CMD_STATUS); // 读取nand状态
    do {
        State = NF_READ_BYTE();
    } while(!(State & (1<<6))); // 等待状态变成Ready
    NF_CE_DISABLE();
    // 是否写成功,第0位为0则pass,不然fail
    if (State & (1<<0)) {
        if (Nand_MarkBadBlock(Block)) { // 标志坏块
            return 3; // 写不成功并且坏块标记不成功
        } else {
            return 4; // 写不成功坏块标记成功
        }
    }
    return 0;
}

1.6 Nand坏块判定

Nand写时应先判定所在块是否坏块，若是，则应跳过写这一块，并标记这一块为坏块。坏块标记我们约定用spare区偏移处第六字节来作标志，坏块这一字节标志为非0xff，好块为0xff。我们读取block中页0，spare区第六字节的值即可判断这个block是否坏块，代码实现如下：

unsigned charNand_IsBadBlock(unsigned int Block)
{
    unsigned char Data;
    // 每个block第一页spare区第6字节为0xff标记为好坏
    Nand_RamdomRead(Block, 0, 2054, 1,&Data);
    if (Data != 0xff){
        return 1; // 坏块
    }
    return 0;
}

1.7 Nand随机地址读

对于标记读取坏块中的标志，往往只需要访问一页中的几个字节，Nand随机地址读写即可实现访问一页中的相应字节。一页中随机地址读函数实现如下：

// Block为Nand块区号
// Page为对应块中的页号
// Address为页内随机地址
// Length为读取长度
// Buffer为数据缓存区
static unsigned char Nand_RamdomRead(unsigned int Block, unsigned intPage,
                unsigned intAddress, unsigned short Length,
                unsigned char *Buffer)
{
    unsigned short i;
    if (Address + Length > 2048+64) {
        return 1; // 页内地址及写入长度不能超出该页范围
    }
    if (Buffer == (void *)0 || Length == 0) {
        return 2; // 参数错误
    }  
    Page += (Block << 6); // Block转换为页数   
    NF_CE_ENABLE();
    NF_CLEAR_RB();
    NF_CMD(NAND_CMD_READ0); // page read cycle 1
    NF_ADDR(0); // column address
    NF_ADDR(0); // columu address
    NF_ADDR(Page & 0xff); // 传输3字节的页地址
    NF_ADDR((Page>>8) & 0xff);
    NF_ADDR((Page>>16) & 0xff);
    NF_CMD(NAND_CMD_READSTART); // page readcycle 2   
    NF_WAIT_READY(); // 等待页读完成
    NF_CMD(NAND_CMD_RNDOUT); // ramdom readcycle 1
    NF_ADDR(Address & 0xff); // 2 cycle addressin page
    NF_ADDR((Address>>8) & 0xf);
    NF_CMD(NAND_CMD_RNDOUTSTART); // ramdom readcycle 2
    for (i=0; i<Length; i++) {
        Buffer[i] = NF_READ_BYTE(); // 读取Length长度数据
    }  
    NF_CE_DISABLE();
    return 0;
}

1.8 Nand随机地址写

写入一页中几个字节数据时，需要用到Nand随机地址写，函数实现如下：

// Block为Nand块区号
// Page为对应块中的页号
// Address为页内随机地址
// Length为写入长度
// Buffer为数据缓存区
static unsigned char Nand_RamdomWrite(unsigned int Block, unsigned intPage,
                    unsigned intAddress, unsigned short Length,
                    unsigned char *Buffer)
{
    unsigned short i;
    unsigned char State;
    if (Address + Length > 2048+64) {
        return 1; // 页内地址及写入长度不能超出该页范围
    }
    if (Buffer == (void *)0 ||Length == 0) {
        return 2; // 参数错误
    }
    Page += (Block << 6); //Block转换为页数   
    NF_CE_ENABLE();
    NF_CLEAR_RB();
    NF_CMD(NAND_CMD_SEQIN); // 页写周期1
    NF_ADDR(0);// column address
    NF_ADDR(0); // columu address
    NF_ADDR(Page & 0xff); // 3字节页地址
    NF_ADDR((Page>>8) & 0xff);
    NF_ADDR((Page>>16) & 0xff);
    NF_CMD(NAND_CMD_RNDIN); // 页内随机写命令
    NF_ADDR(Address & 0xff); // 2字节页内地址
    NF_ADDR((Address>>8) & 0xf);       
    for (i=0; i<Length; i++) {
        NF_WRITE_BYTE(Buffer[i]); // 写入Length长数据
    }
    NF_CMD(NAND_CMD_PAGEPROG); // 页写周期2
    NF_WAIT_READY(); // 等待写完   
    NF_CMD(NAND_CMD_STATUS); // 读取写结果状态
    do {
        State = NF_READ_BYTE();
    } while(!(State & (1<<6))); // 等待状态变成Ready
    NF_CE_DISABLE();   
    if (State & (1<<0)) {
        return 3; // ramdom write error
    }
    return 0;
}

1.9 坏块标记

如果检查出坏块，需要对相应的块在约定位置进行坏块标记，以免再对这个坏块进行读写。其代码实现如下：

unsigned charNand_MarkBadBlock(unsigned int Block)
{
    // 每个block第一页spare区第6字节标记非0xff坏块
    unsigned charData = 0x55;
    return Nand_RamdomWrite(Block, 0, 2054, 1,&Data);
}

1.10 块区擦除

数据写入块区前，对应的块应已擦除好，擦除失败，则认为是坏块，并标注。其代码实现如下：

unsigned charNand_EraseBlock(unsigned int Block)
{
    unsigned char State;
    NF_CE_ENABLE();
    NF_CLEAR_RB();
    NF_CMD(NAND_CMD_ERASE1); // erase blockcommand cycle 1
    // write 3 cycle block address[A28:A18]
    NF_ADDR((Block<<6) & 0xff); //[A19:A18]
    NF_ADDR((Block>>2) & 0xff); //[A27:A20]
    NF_ADDR((Block>>10) & 0xff); //A28
    NF_CMD(NAND_CMD_ERASE2); // erase blockcommand cycle 2
    NF_WAIT_READY();
    NF_CMD(NAND_CMD_STATUS);
    do {
        State = NF_READ_BYTE();
    } while(!(State & (1<<6))); // 等待状态变成Ready
    NF_CE_DISABLE();
    // 是否擦写成功,第0位为0则pass,不然fail
    if (State & (1<<0)) {
        if (Nand_MarkBadBlock(Block)) {
            return3; // 擦除不成功并且坏块标记不成功
        } else {
            return 4; // 擦除不成功坏块标记成功
        }
    }  
    return 0; // 成功擦除
}

1.11 接口函数写

对于实际的应用，往往需要对Nand进行一定长度代码或数据的写入或读取，并且判断出坏块，则应跳过读写。因此，Nand模块还应实现任意长度代码、数据的写入或读取接口函数功能，接口函数写实现如下：

// Address为Nand字节偏移地址(从Nand芯片最前面开始索引)
// Buffer为数据缓存区(作为从Buffer指向的地址开始拷贝的源地址)
// Length为写长度(从Buffer指向的地址开始连续读取的字节个数)
unsigned charNand_WriteSkipBad(unsigned int Address,
            unsigned char *Buffer, unsigned intLength)
{
    unsigned int BlockIndex, PageIndex;
    unsigned int WriteBytes;
    unsigned char i;
    unsigned char State;
    if (Length == 0 || Buffer == (void *)0) {
        return 1; // 参数错误
    }
    if ((Address & 0xfff) != 0) {
        return 2; // nand地址非页对齐,读最小单位为1页
    }
    State = 0;
    WriteBytes = 0; // 己写字节数
    PageIndex = (Address >> 11) &0x3f; // 块中的页偏移位置
    BlockIndex = Address >> 17; // 块写位置
    while (1) {
        if (Nand_EraseBlock(BlockIndex)) {
            BlockIndex++; // 坏块,跳过到下一块
            continue;
        }
        for (i=PageIndex; i<64; i++) {
            if (Nand_WritePage(BlockIndex, i,Buffer)) {// 写一页
                if (State == 1) {
                    State=2; // write errortwice
                    // 再次写错误,认为是坏块,取消这块写的数据
                    WriteBytes-= 2048 * (i-PageIndex);
                    // 调整内存位置到写这块之前
                    Buffer -= 2048 *(i-PageIndex);        
                    break;
                } else {
                    State = 1;
                    i -= 1; // 写出错，尝试再次写该页
                    continue;
                }
            }
            WriteBytes += 2048; // 写取了一页数据
            if (WriteBytes >= Length) {
                break; // 数据写入完退出
            }
            State = 0;
            Buffer += 2048; // 下一页内存存储位置  
        }
        if (State == 2) { // 两次写均出错,跳过到下一块
            BlockIndex++;
            State = 0;
            continue;
        }
        if (WriteBytes >= Length) {
            break; // 写完退出循环
        }
        PageIndex = 0; // 下一块从第一页开始写
        BlockIndex++; // 再写下一个块  
    }  
    return 0;
}

1.12 接口函数读

接口函数读实现如下：

// Address为Nand字节偏移地址(从Nand芯片最前面开始索引)
// Buffer为数据缓存区(作为从Nand拷贝数据到的目标地址)
// Length为读取长度(从Nand的Address开始连续读取的字节个数)
unsigned charNand_ReadSkipBad(unsigned int Address,
            unsigned char *Buffer, unsigned intLength)
{
    unsigned int BlockIndex, PageIndex;
    unsigned int ReadBytes;
    unsigned char i;
    unsigned char State;
    if (Length == 0 || Buffer == (void *)0) {
        return 1; // 参数错误
    }
    if ((Address & 0xfff) != 0) {
        return 2; // nand地址非页对齐,读最小单位为1页
    }
    State = 0;
    ReadBytes = 0; // 已读字节数
    PageIndex = (Address >> 11) &0x3f; // 块中的页偏移位置
    BlockIndex = Address >> 17; // 块读位置
    while (1) {
        if (Nand_IsBadBlock(BlockIndex)) {
            BlockIndex++; // 坏块,跳过读取下一块
            continue;
        }
        for (i=PageIndex; i<64; i++) { // 读取一个block
            if (Nand_ReadPage(BlockIndex, i,Buffer)) {
                if (State == 1) {
                    State=2; // read error twice
                    // 再次读错误,认为是坏块,取消这块读的数据
                    ReadBytes -=2048 * (i-PageIndex);
                    // 调整内存位置到读取这块之前
                    Buffer -= 2048* (i-PageIndex);            
                    break;
                } else {
                    State = 1;
                    i -= 1; // 读出错，尝试再次读该页
                    continue;
                }
            }
            ReadBytes += 2048; // 读取了一页数据
            if (ReadBytes >=Length) {
                break; // 读取数据足够则退出
            }
            State = 0;
            Buffer += 2048; // 下一页内存存储位置  
        }
        if (State == 2) { // 两次读取均出错,跳过到下一块
            BlockIndex++;
            State = 0;
            continue;
        }
        if (ReadBytes >= Length){
            break; // 读完退出循环
        }
        PageIndex = 0; // 下一块从第一页开始读
        BlockIndex++; // 读下一个块
    }
    return 0;
}

2. Nand启动

写好了Nand驱动，即可调用Nand驱动接口函数实现代码从Nand读取到RAM，或把代码从RAM固化进Nand。Nand启动从Nand搬移代码到RAM，我们首先要确定代码运行的RAM基址，以及拷贝的代码大小，最后调用Nand_ReadSkipBad从Nand 0x0地址偏移处读取即可。对于代码需固化到Nand，我们传入链接器给出的代码基址和代码大小参数，最后调用Nand_WriteSkipBad从Nand 0x0地址偏移处写入即可，我们给出Nand代码烧录调用函数如下：

// 从运行代码的RAM位置,指定一定长度的代码烧写进Nand 0x0偏移处
unsigned char WriteCodeToNand()
{
// 在板级代码LowLevelInit.s中引出了链接器生成的代码大小，代码运行地址信息:
//      __CodeAddr__为代码拷贝到的RAM位置，链接文件中设定
//      __CodeSize__为二进制代码编译生成的大小，链接器最终链接后给出
    externunsigned int __CodeAddr__;
    extern unsigned int __CodeSize__;  
    unsigned char State;
    Nand_Init(); // Nand时序初始化
    //将__CodeAddr__位置开始，长度为__CodeSize__一块代码写入到Nand第0块第0页位置处.
    State = Nand_WriteSkipBad(0, (unsigned char *)__CodeAddr__,__CodeSize__);
    return State;
}

在启动代码中，我们需要识别出Nand启动，并调用Nand_ReadSkipBad接口函数即可把代码从Nand读取到代码,然后拷贝到到运行内存位置。在LowLevelInit.s板级文件中，我们修改CopyCodeToRAM，判别是Nand启动还是IROM SD/MMC启动，并调用相应的设备代码拷贝函数即可。我们可以借用NFCONF(0x4E000000)寄存器的最高位判断是否为1来确定是否从Nand启动？如果为1则从Nand启动，如果为0则认为是IROM SD/MMC启动。 CopyCodeToRAM函数加入Nand启动后的代码如下：

; SD/MMCDevice Boot Block Assignment
eFuseBlockSize          EQU     1
SdReservedBlockSize     EQU     1
BL1BlockSize            EQU     16
SdBL1BlockStart         EQU     SdReservedBlockSize+ \
                        eFuseBlockSize + BL1BlockSize
globalBlockSizeHide     EQU     0x40003FFC
CopyMovitoMem           EQU     0x40004008
; Nandcontroller base address Nand控制器基地址
NFCONF          EQU     0x4E000000
                EXPORT  __CodeSize__
                EXPORT  __CodeAddr__
; 引出代码搬移函数，以供启动代码调用
                EXPORT  CopyCodeToRAM
; 引入Nand启动的初始化函数及Nand读函数
                IMPORT  Nand_Init
                IMPORT  Nand_ReadSkipBad
; 引入链接器产生符号，以确定代码运行位置，编译生成的大小
                IMPORT  ||ImageERROM0Base||
                IMPORT  ||LoadERROM0Length||  
                IMPORT  ||LoadERROM1Length||  
                IMPORT  ||LoadRWRAMRW$$Length||
; 链接器产生代码链接运行位置
__CodeAddr__    DCD     ||ImageERROM0Base||
; 链接器各个段需保存的代码以及需初始代的变量大小
__CodeSize__    DCD     ||LoadERROM0Length||+ \
                ||LoadERROM1Length|| + \
                ||LoadRWRAMRW$$Length||   
;功能:实现从SD或Nand拷贝代码到DDR2指定位置(__CodeAddr__用来指定对应的内存位置)处.             
CopyCodeToRAM
        ;压栈
        STMFD   SP!,{LR} ; 保存返回地址
        ; 判断NFCONF的最高位为1，说明启动设备为Nand    
        LDR     R0, =NFCONF
        LDR     R1,[R0]
        AND     R1,R1, #0x80000000
        //如果bit[31]不为1,则跳转到MMC_SD_Boot位置,否则继续往下运行:
        CMP     R1,#0x80000000
        BNE     MMC_SD_Boot
;执行到这说明是从Nand启动: 
Nand_Boot
        ;先初始化Nand芯片
        BL      Nand_Init   ; Nand初始化
        ;
        ;调用 Nand_ReadSkipBad(R0,R1,R2) 时传递的3个参数R0,R1,R2
        MOV     R0,#0               ;R0=0 Nand的开始位置
        LDR     R1,__CodeAddr__     ;R1=DDR2内存目标地址,用来放置从Nand拷贝过来的代码的位置
        LDR     R2,__CodeSize__     ;要拷贝的代码大小
        BL      Nand_ReadSkipBad    ;调用Nand读函数
        MOVS    R0, R0              ;返回值确定调用Nand_ReadSkipBad()函数是否成功.
Nand_Boot_Loop 
        BNE     Nand_Boot_Loop      ;返回非0说明拷贝失败,那么就一直死循环在Nand_Boot_Loop处.
        ;执行到这里就说明上面读取成功,可以继续执行AfterCopy标号位置,用来返回当前CopyCodeToRAM()子程序
        B       AfterCopy
;SD启动子程序:       
MMC_SD_Boot
; 不需要卡初始化
        LDR     R3,=0
; 拷贝sd卡代码到链接执行域内存代码处
        LDR     R2, __CodeAddr__
;               
; 计算代码的大小，以block计，不足512字节的算1个block
; 代码的大小包括Code RO-data RW-data(代码需保存需初始化的RW的初始值)
; 代码保存在ROM中,应从加载域得到ROM的大小,而不是执行域,编译器可能压缩
; 代码段保存在加载域的ROM中
        LDR     R0, __CodeSize__
        LDR     R1,=0x1ff
        TST     R0,R1 ; 是否不足一个block(512Bytes)
        BEQ     %F0; 代码恰好block对齐，不用加多一个block
        ADD     R0,R0, #512               
0       LSR     R1,R0, #9 ; 得到代码的block大小
; 计算代码在SD/MMC卡中的block起启地址
        LDR     R4,=SdBL1BlockStart   
        LDR     R0,=globalBlockSizeHide
        LDR     R0,[R0] ; SD/MMC的总block块
        SUB     R0,R4 ; 减去保留块及BL1大小
        CMP     R1,#16 ; 代码不足8k,直接BL1处拷贝
        BLS     ParameterOK; 代码少于16个block跳转
        SUB     R0,R1 ; 再减去代码的大小，代码的block位置
; 
; 调用IROM Movi拷贝函数，仅适用于IROM启动，卡访问时钟25M   
ParameterOK
        LDR     R4,=CopyMovitoMem
        LDR     R4,[R4]
        BLX     R4
        MOVS    R0,R0 ; 返回值确定函数成功还是失败
MMC_SD_Boot_Loop           
        BEQ     MMC_SD_Boot_Loop; 返回0说明拷贝失败
;
;从当前子程序返回               
AfterCopy  
        LDMFD   SP!, {PC} ; 函数返回

对于S3C2416来说，不借助昂贵的烧写工具，只有SD卡能直接烧写进代码，对于需要把代码固化进Nand，需先设置代码从SD卡启动，然后再通过某一触发条件(如某一按键输入作为下载键)调用WriteCodeToNand函数把代码烧写进Nand，以后设置从Nand启动即可。

3. 附录

至此，启动代码已支持Nand启动以及sd卡启动，c代码运行环境RAM资源可达64MB。 LowLevelInit.s，板级初始化代码实现，包括DDR2初始化函数实现，代码拷贝函数实现，实现Nand启动以及sd卡启动。 Nand.h / Nand.c，Nand模块接口头文件以及Nand驱动功能实现。 源码下载： http://pan.baidu.com/s/1mgqfJWO