S3C2416裸机开发系列五_Nand驱动以及Nand启动

来源：互联网发布：天书世界暗器进阶数据编辑：程序博客网时间：2024/05/19 09:39

S3C2416裸机开发系列五

Nand驱动以及Nand启动

象棋小子 1048272975

在嵌入式设计中，由于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字节偏移地址，Buffer为数据缓存区

// Length为写长度

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字节偏移地址，Buffer为数据缓存区

// Length为读取长度

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时序初始化

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启动，为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

NFCONF EQU 0x4E000000

EXPORT __CodeSize__

EXPORT __CodeAddr__

; 引出代码搬移函数，以供启动代码调用

EXPORT CopyCodeToRAM

; 引入Nand启动的初始化函数及Nand读函数

IMPORT Nand_Init

IMPORT Nand_ReadSkipBad

; 引入链接器产生符号，以确定代码运行位置，编译生成的大小

IMPORT ||Image$$ER_ROM0$$Base||

IMPORT ||Load$$ER_ROM0$$Length||

IMPORT ||Load$$ER_ROM1$$Length||

IMPORT ||Load$$RW_RAM$$RW$$Length||

; 链接器产生代码链接运行位置

__CodeAddr__ DCD ||Image$$ER_ROM0$$Base||

; 链接器各个段需保存的代码以及需初始代的变量大小

__CodeSize__ DCD ||Load$$ER_ROM0$$Length||+ \

||Load$$ER_ROM1$$Length|| + \

||Load$$RW_RAM$$RW$$Length||

CopyCodeToRAM

STMFD SP!,{LR} ; 保存返回地址

; 判断NFCONF的最高位为1，说明启动设备为Nand

LDR R0, =NFCONF

LDR R1,[R0]

AND R1,R1, #0x80000000

CMP R1,#0x80000000

BNE MMC_SD_Boot

Nand_Boot

BL Nand_Init; Nand初始化

MOV R0,#0

LDR R1,__CodeAddr__

LDR R2,__CodeSize__

BL Nand_ReadSkipBad;调用Nand读函数

MOVS R0, R0 ; 返回值确定函数成功还是失败

Nand_Boot_Loop

BNE Nand_Boot_Loop;返回非0说明拷贝失败

B AfterCopy

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

0 0