S3C2416裸机开发系列五_Nand驱动以及Nand启动
2014-03-24 09:58
393 查看
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
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- S3C2416裸机开发系列二_汇编入门代码以及sd卡启动
- S3C2416裸机开发系列三_启动代码以及流水灯c代码
- S3C2416裸机开发系列一_裸机开发环境以及启动模式
- S3C2416裸机开发系列十八_音频驱动实现(1)
- S3C2416裸机开发系列十八_音频驱动实现(2)
- S3C2416裸机开发系列十六_sd卡驱动实现
- S3C2416裸机开发系列四_外部内存初始化以及代码搬移
- S3C2416裸机开发系列十二_IIC驱动实现
- S3C2416裸机开发系列九_GCC启动代码工程应用实例
- S3C2416裸机开发系列十三_电容屏驱动实现
- S3C2416裸机开发系列十一_RGB屏驱动显示
- S3C2416裸机开发系列八_MDK启动代码工程应用实例
- S3C2416裸机开发系列十六_sd卡驱动实现
- 测试驱动开发系列之四--代码中的坏味道以及如何改进他们
- S3C2416裸机开发系列十_串口打印调试
- S3C2416裸机开发系列六_MMU映射
- Exynos4412裸机开发系列教程－－启动流程
- S3C2416裸机开发系列十五_GCC下uCOS的移植(1)
- S3C2416裸机开发系列十七_GCC下Fatfs的移植
- S3C2416裸机开发系列二十_Libjpeg的移植