U-boot学习笔记(二)

最新推荐文章于 2022-01-22 00:00:17 发布
最新推荐文章于 2022-01-22 00:00:17 发布
阅读量1.3k 收藏
点赞数
文章标签： flash c cmd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq236106303/article/details/7054714
版权

让U-boot支持NAND Flash启动

  • 修改cpu/arm920t/start.S修改代码搬移程序

#if 1
	bl  CopyCode2Ram	/* r0: source, r1: dest, r2: size */
#else
	add	r2, r0, r2		/* r2 <- source end address         */

copy_loop:
	ldmia	r0!, {r3-r10}		/* copy from source address [r0]    */
	stmia	r1!, {r3-r10}		/* copy to   target address [r1]    */
	cmp	r0, r2			/* until source end addreee [r2]    */
	ble	copy_loop
#endif

  • 增加CopyCode2Ram函数以及子函数,修改board目录下目标板的boot_init.c。
#include <common.h>
#include <s3c2410.h>

#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)

/* 供外部调用的函数 */
void nand_init_ll(void);
void nand_read_ll(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(void);

/* 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();
    s3c2410_nand_deselect_chip();
}

/* 等待NAND Flash就绪 */
static void s3c2410_wait_idle(void)
{
    int i;
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;
	
    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;
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;

    s3c2410nand->NFCONF &= ~(1<<11);
    for(i=0; i<10; i++);    
}

/* 取消片选信号 */
static void s3c2410_nand_deselect_chip(void)
{
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;

    s3c2410nand->NFCONF |= (1<<11);
}

/* 发出命令 */
static void s3c2410_write_cmd(int cmd)
{
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;

    volatile unsigned char *p = (volatile unsigned char *)&s3c2410nand->NFCMD;
    *p = cmd;
}

/* 发出地址 */
static void s3c2410_write_addr(unsigned int addr)
{
    int i;
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;
    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)
{
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;

    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();
    s3c2440_nand_deselect_chip();
}

/* 等待NAND Flash就绪 */
static void s3c2440_wait_idle(void)
{
    int i;
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFSTAT;

    while(!(*p & BUSY))
        for(i=0; i<10; i++);
}

/* 发出片选信号 */
static void s3c2440_nand_select_chip(void)
{
    int i;
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;

    s3c2440nand->NFCONT &= ~(1<<1);
    for(i=0; i<10; i++);    
}

/* 取消片选信号 */
static void s3c2440_nand_deselect_chip(void)
{
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;

    s3c2440nand->NFCONT |= (1<<1);
}

/* 发出命令 */
static void s3c2440_write_cmd(int cmd)
{
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;

    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFCMD;
    *p = cmd;
}

/* 发出地址 */
static void s3c2440_write_addr(unsigned int addr)
{
    int i;
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;
    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++);
}


/* 发出地址 */
static void s3c2440_write_addr_lp(unsigned int addr)
{
    int i;
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFADDR;
	int col, page;

	col = addr & NAND_BLOCK_MASK_LP;
	page = addr / NAND_SECTOR_SIZE_LP;
	
    *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)
{
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;
    volatile unsigned char *p = (volatile unsigned char *)&s3c2440nand->NFDATA;
    return *p;
}


/* 在第一次使用NAND Flash前，复位一下NAND Flash */
static void nand_reset(void)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_nand_reset();
	}
	else
	{
	    s3c2440_nand_reset();
	}
}

static void wait_idle(void)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_wait_idle();
	}
	else
	{
	    s3c2440_wait_idle();
	}
}

static void nand_select_chip(void)
{
    int i;
	
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_nand_select_chip();
	}
	else
	{
	    s3c2440_nand_select_chip();
	}
	
    for(i=0; i<10; i++);
}

static void nand_deselect_chip(void)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_nand_deselect_chip();
	}
	else
	{
	    s3c2440_nand_deselect_chip();
	}	
}

static void write_cmd(int cmd)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_write_cmd(cmd);
	}
	else
	{
	    s3c2440_write_cmd(cmd);
	}	
}
static void write_addr(unsigned int addr)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_write_addr(addr);
	}
	else
	{
	    s3c2440_write_addr(addr);
	}	
}

static void write_addr_lp(unsigned int addr)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    s3c2410_write_addr(addr);
	}
	else
	{
	    s3c2440_write_addr_lp(addr);
	}	
}

static unsigned char read_data(void)
{
    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
	{
	    return s3c2410_read_data();
	}
	else
	{
	    return s3c2440_read_data();
	}	
}

/* 初始化NAND Flash */
void nand_init_ll(void)
{
	S3C2410_NAND * s3c2410nand = (S3C2410_NAND *)0x4e000000;
	S3C2440_NAND * s3c2440nand = (S3C2440_NAND *)0x4e000000;

#define TACLS   0
#define TWRPH0  3
#define TWRPH1  0

    /* 判断是S3C2410还是S3C2440 */
    if (isS3C2410)
    {
		/* 使能NAND Flash控制器, 初始化ECC, 禁止片选, 设置时序 */
        s3c2410nand->NFCONF = (1<<15)|(1<<12)|(1<<11)|(TACLS<<8)|(TWRPH0<<4)|(TWRPH1<<0);
    }
    else
    {
		/* 设置时序 */
        s3c2440nand->NFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4);
        /* 使能NAND Flash控制器, 初始化ECC, 禁止片选 */
        s3c2440nand->NFCONT = (1<<4)|(1<<1)|(1<<0);
    }

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


/* 读函数 */
void nand_read_ll(unsigned char *buf, unsigned long start_addr, int size)
{
    int i, j;
    
    if ((start_addr & NAND_BLOCK_MASK) || (size & NAND_BLOCK_MASK)) {
        return ;    /* 地址或长度不对齐 */
    }

    /* 选中芯片 */
    nand_select_chip();

    for(i=start_addr; i < (start_addr + size);) {
      /* 发出READ0命令 */
      write_cmd(0);

      /* Write Address */
      write_addr(i);
      wait_idle();

      for(j=0; j < NAND_SECTOR_SIZE; j++, i++) {
          *buf = read_data();
          buf++;
      }
    }

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


/* 读函数 
  * Large Page
  */
void nand_read_ll_lp(unsigned char *buf, unsigned long start_addr, int size)
{
    int i, j;
    
    if ((start_addr & NAND_BLOCK_MASK_LP) || (size & NAND_BLOCK_MASK_LP)) {
        return ;    /* 地址或长度不对齐 */
    }

    /* 选中芯片 */
    nand_select_chip();

    for(i=start_addr; i < (start_addr + size);) {
      /* 发出READ0命令 */
      write_cmd(0);

      /* Write Address */
      write_addr_lp(i);
	  write_cmd(0x30);
      wait_idle();

      for(j=0; j < NAND_SECTOR_SIZE_LP; j++, i++) {
          *buf = read_data();
          buf++;
      }
    }

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

int bBootFrmNORFlash(void)
{
    volatile unsigned int *pdw = (volatile unsigned int *)0;
    unsigned int dwVal;
    
    /*
     * 无论是从NOR Flash还是从NAND Flash启动，
     * 地址0处为指令"b	Reset", 机器码为0xEA00000B，
     * 对于从NAND Flash启动的情况，其开始4KB的代码会复制到CPU内部4K内存中，
     * 对于从NOR Flash启动的情况，NOR Flash的开始地址即为0。
     * 对于NOR Flash，必须通过一定的命令序列才能写数据，
     * 所以可以根据这点差别来分辨是从NAND Flash还是NOR Flash启动:
     * 向地址0写入一个数据，然后读出来，如果没有改变的话就是NOR Flash
     */

    dwVal = *pdw;       
    *pdw = 0x12345678;
    if (*pdw != 0x12345678)
    {
        return 1;
    }
    else
    {
        *pdw = dwVal;
        return 0;
    }
}

int CopyCode2Ram(unsigned long start_addr, unsigned char *buf, int size)
{
    unsigned int *pdwDest;
    unsigned int *pdwSrc;
    int i;

    if (bBootFrmNORFlash())
    {
        pdwDest = (unsigned int *)buf;
        pdwSrc  = (unsigned int *)start_addr;
        /* 从 NOR Flash启动 */
        for (i = 0; i < size / 4; i++)
        {
            pdwDest[i] = pdwSrc[i];
        }
        return 0;
    }
    else
    {
        /* 初始化NAND Flash */
		nand_init_ll();
        /* 从 NAND Flash启动 */
        nand_read_ll_lp(buf, start_addr, (size + NAND_BLOCK_MASK_LP)&~(NAND_BLOCK_MASK_LP));
		return 0;
    }
}
make clean

make 

然后烧写到nandflash启动。


qq236106303
关注
u-boot学习笔记.pdf
11-17
### U-Boot 1.1.6 目录结构及启动流程详解 #### 一、U-Boot 1.1.6 目录结构解析 U-Boot (Universal Boot Loader) 是一个支持多种处理器架构的开源BootLoader...这对于学习和开发基于 U-Boot 的嵌入式系统至关重要。
堆栈的工作原理
奔跑的路
10-29 2万+
声明：以下均为个人见解，错漏地方还请指正 每一个使用c语言的都应该知道栈的重要性，我们能够使用C/C++语言写出诸多复杂的程序，很大功劳一部分有归于栈的实现，因为它可以帮助我们实现函数间的嵌套调用。 汇编程序的运行是不需要栈的，所以注定它函数的嵌套层数不会太多，一般是父函数调用子函数，然后在子函数就返回了，很少见到子函数还会调用孙子函数的情况。这是由它的语言特性决定的。因为每当汇编语言
堆栈的原理解析学习笔记
jacklin_01的博客
08-13 1317
每一个使用c语言的都应该知道栈的重要性，我们能够使用C/C++语言写出诸多复杂的程序，很大功劳一部分有归于栈的实现，因为它可以帮助我们实现函数间的嵌套调用。 汇编程序的运行是不需要栈的，所以注定它函数的嵌套层数不会太多，一般是父函数调用子函数，然后在子函数就返回了，很少见到子函数还会调用孙子函数的情况。这是由它的语言特性决定的。因为每当汇编语言调用子函数时，就会将返回的PC地址保存在LR中， 如果子函数还要调用孙子函数，那么执行时也会将子函数的返回地址保存在LR中，这时如果要返回父函数，就需要将返回父PC
ARM--嵌入式系统启动例程
wxie的Linux人生
05-18 2392
通常PC在开机之后，会进入带有PC机厂商信息的BIOS画面，并且会显示出当前PC机的硬件信息，比如：内存大小，CPU信息等，它其实是PC机启动之后运行的第一段程序，它主要完成一些基本硬件初始化操作和硬件检测工作，保证拥有操作系统正常运行的软硬件环境，随后会加载并且启动操作系统。该段小程序是烧制到主板上的BIOS存储硬件里的。由此可见计算机系统在启动过程中必须依赖软硬件，在嵌入式系统中同样需要软硬件
汇编程序调用C函数需要设置栈的原因
饕餮的阿周
08-04 527
汇编程序调用C函数需要设置栈的原因总的来说，它的作用就是：保存现场/上下文，传递参数，保存临时变量
堆栈指针寄存器 SP详解以及栈的作用
热门推荐
蓝色鲜橙多的博客
05-06 3万+
本文引用地址：http://www.eepw.com.cn/article/201611/321963.htm 韦东山：https://blog.csdn.net/thisway_diy/article/details/76422943 堆栈是一种具有“后进先出”（LIFO---Last In First Out）特殊访问属性的存储结构。堆 栈一般使用RAM 物理资源作为存储体，再加上LI...
u-boot-1.1.6学习笔记
03-23
### U-Boot 1.1.6学习笔记详解 #### 目录结构解析 U-Boot（Universal Boot Loader）作为一款广泛使用的嵌入式设备引导加载程序，其1.1.6版本的目录结构体现了其高度模块化和可移植性的设计原则。下面详细解析U-...
u-boot移植笔记[定义].pdf
10-20
《U-Boot移植笔记》是关于嵌入式系统中引导加载程序U-Boot的详细实践指南，主要关注如何将U-Boot...通过这份移植笔记，开发者可以学习到如何将U-Boot适应新的硬件环境，为后续的操作系统部署和应用程序开发奠定基础。
u-boot-1.1.6移植学习笔记
10-30
### U-Boot 1.1.6 移植学习笔记 #### 一、U-Boot 1.1.6 目录结构解析 U-Boot（Universal Boot Loader）是一款广泛应用于嵌入式系统的引导加载程序，它支持多种处理器架构及各种外围设备。U-Boot 1.1.6 的目录结构...
U-Boot移植-思维导图-MX6U嵌入式linux系统移植学习笔记基于正点原子阿尔法开发板
最新发布
12-06
U-Boot移植-思维导图-MX6U嵌入式linux系统移植学习笔记基于正点原子阿尔法开发板
TX2440 ARM开发板Uboot移植（二、让u-boot从nandFlash动起来）
逐波与逆流
04-09 1505
接上：让u-boot从norFlash动起来 完成上面工作后，u-boot中还没有对2440上Nand Flash的支持，以及u-boot从Nand Flash上启动，这些得我们一步步去实现了。 1、修改配置文件 include/configs/smdk2440.h ： 1.1、新增宏 CONFIG_CMD_NAND (大概在95行) #define
将flash中的代码复制到RAM中运行的方法
只要路是对的，就不害怕遥远
06-18 3896
在MCU的使用过程中，偶尔会遇到将flash中的代码复制到RAM中运行的情况，下面就来说一下具体的方法，以28335的flash初始化为例： 1，编写函数，该函数处于flash中，就是我们即将要复制的代码。 void FlashInitCode(void) { EALLOW; //Enable Flash Pipeline mode to improve performance //of code executed from Flash. FlashRegs.FOPT....
MTD原始设备与FLASH硬件驱动的对话-续
dongliqiang2006的专栏
09-03 631
MTD原始设备与FLASH硬件驱动的对话-续上一个贴由下到上的介绍了FLASH硬件驱动是如何与MTD原始设备建立联系的，现在再由上到下的研究一下是如何通过MTD原始设备来访问FLASH硬件驱动的。首先分析一下如何通过MTD原始设备进而通过FLASH硬件驱动来读取FLASH存储器的数据。引用自>一文："读Nand Flash：当对nand flash的设备文件(nand flash在/dev
uboot启动第一阶段
u010743406的博客
01-22 1375
前言： 本帖是学习韦东山老师uboot教程，粗略总结的课堂笔记及自己感悟。如想深入了解uboot 启动过程，请绕路。 相关帖子： UBOOT初体验：编译、下载 初识uboot Makefile 概述 uboot启动第一阶段主要进行单板硬件初始化：看门狗、中断、堆栈等 uboot第一阶段 初识uboot Makefile中我们知道，uboot的第一个文件为cpu/arm920t/start.S，uboot第一阶段所做的工作即为该文件内容。内容见后文。 .globl _st.
Linux内核MTD子系统五之nand_chip初始化分析
Jkf40622的专栏
10-10 2076
初始化基本的硬件配置后probe函数就会开始与NAND芯片进行交互了，它要做的事情主要包括这几个方面：读取NAND芯片的ID，然后查表得到这片NAND芯片的如厂商，page size，erase size以及chip size等信息，接着，根据struct nand_chip中options的值的不同，或者在NAND芯片中的特定位置查找bad block table，或者scan整个NAND芯
U-Boot学习笔记(二):U-Boot--arm--Start.S的分析
--Joern的物联领域--
12-06 571
声明：该贴是通过参考其他人的帖子整理出来，从中我加深了对uboot的理解，我知道对其他人一定也是有很大的帮助，不敢私藏，如果里面的注释有什么错误请给我回复，我再加以修改。有些部分可能还没解释清楚，如果您觉得有必要注释，希望指出。再次强调该贴的大部分功劳应该归功于那些原创者，由于粗心，我没有留意参考的出处。我的目的是想让大家共同进步。希望大家念在我微不足道的心意，能够积极回馈，以便使帖子更加完善。以
你知道吗？为何C语言函数调用要堆栈，而汇编却不需要？
super_marie的博客
05-19 602
最近，看了很多关于uboot的分析，其中就有说要为C语言的运行，就要准备好堆栈。而在Uboot的start.S汇编代码中，关于系统初始化，也看到有堆栈指针初始化这个动作。但是，从来只是看到有人说系统初始化要初始化堆栈，即正确给堆栈指针sp赋值，但是却从来没有看到有人解释，为何要初始化堆栈。   今天，我们就来试图解释一下，为何要初始化堆栈，即：   为何C语言的函数调用
U-Boot学习笔记概要及关键概念
这份学习笔记详细介绍了U-Boot的各个方面。 1. U-Boot工程简介 U-Boot是Bootloader的一种，主要任务是在系统启动时设置硬件环境，加载操作系统到内存，并将控制权传递给操作系统。它的设计目标是灵活性和可移植性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值