本文对uboot中的start_armboot()函数进行分析，以便理清uboot第二阶段的初始化工作流程

uboot源码分析-第二阶段(C语言)

本文对uboot中的start_armboot()函数进行分析，以便理清uboot第二阶段的初始化工作流程

uboot 第二阶段的功能

uboot第一阶段主要就是初始化了SoC内部的一些部件（譬如看门狗、时钟），然后初始化DDR并且完成重定位。
uboot的第二阶段就是要初始化剩下的还没被初始化的硬件。主要是SoC外部硬件（譬如iNand、网卡芯片····）、uboot本身的一些东西（uboot的命令、环境变量等····）。然后最终初始化完必要的东西后进入uboot的命令行准备接受命令。

下面我们就进入 start_armboot() 开始分析

start_armboot

函数指针数组 init_fnc_t

typedef int (init_fnc_t) (void); 定义了一个函数类型
init_fnc_ptr是一个二重函数指针，二重指针的作用有2个（其中一个是用来指向一重指针），一个是用来指向指针数组。这里的init_fuc_ptr用来指向一个函数指针数组。

DECLARE_GLOBAL_DATA_PTR

#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("r8")

定义了一个全局变量名字叫gd,这个全局变量是一个指针类型，占4字节。用volatile修饰表示可变的，用register修饰表示这个变量要尽量放到寄存器中，后面的asm(“r8”)是gcc支持的一种语法，意思就是要把gd放到寄存器r8中。
综合分析，DECLARE_GLOBAL_DATA_PTR就是定义了一个要放在寄存器r8中的全局变量，名字叫gd，类型是一个指向gd_t类型变量的指针。
定义为register是因为这个全局变量gd（global data的简称）是uboot中很重要的一个全局变量（准确的说这个全局变量是一个结构体，里面有很多内容，这些内容加起来构成的结构体就是uboot中常用的所有的全局变量），这个gd在程序中经常被访问，因此放在register中提升效率。因此纯粹是运行效率方面考虑，和功能要求无关。并不是必须的。
gd_t中定义了很多全局变量，都是整个uboot使用的；其中有一个bd_t类型的指针，指向一个bd_t类型的变量，这个bd是开发板的板级信息的结构体，里面有不少硬件相关的参数，譬如波特率、IP地址、机器码、DDR内存分布。

内存使用排布

ulong gd_base;

gd_base = CFG_UBOOT_BASE + CFG_UBOOT_SIZE - CFG_MALLOC_LEN \
           - CFG_STACK_SIZE - sizeof(gd_t);

gd = (gd_t*)gd_base;

/* compiler optimization barrier needed for GCC >= 3.4 */
__asm__ __volatile__("": : :"memory");

memset ((void*)gd, 0, sizeof (gd_t));
gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));
memset (gd->bd, 0, sizeof (bd_t));

为什么要分配内存

DECLARE_GLOBAL_DATA_PTR只能定义了一个指针，也就是说gd里的这些全局变量并没有被分配内存，我们在使用gd之前要给他分配内存，否则gd也只是一个野指针而已。
gd和bd需要内存，内存当前没有被人管理（因为没有操作系统统一管理内存），大片的DDR内存散放着可以随意使用（只要使用内存地址直接去访问内存即可）。但是因为uboot中后续很多操作还需要大片的连着内存块，因此这里使用内存要本着够用就好，紧凑排布的原则。所以我们在uboot中需要有一个整体规划。

内存排布

分区	说明
uboot区	`CFG_UBOOT_BASE-xx`（长度为uboot的实际长度）
堆区	长度为`CFG_MALLOC_LEN`，实际为912KB
栈区	长度为`CFG_STACK_SIZE`，实际为512KB
gd	长度为`sizeof(gd_t)`，实际36字节
bd	长度为`sizeof(bd_t)`，实际为44字节左右
内存间隔	为了防止高版本的gcc的优化造成错误

循环执行 init_squence

for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
    if ((*init_fnc_ptr)() != 0) {
        hang ();
    }
}

init_sequence是一个函数指针数组，数组中存储了很多个函数指针，这些指向指向的函数都是init_fnc_t类型（特征是接收参数是void类型，返回值是int）。
init_fnc_ptr是一个二重函数指针，可以指向init_sequence这个函数指针数组。
init_fnc_t的这些函数的返回值定义方式一样的，都是：函数执行正确时返回0，不正确时返回-1.所以我们在遍历时去检查函数返回值，如果遍历中有一个函数返回值不等于0则hang()挂起。从分析hang函数可知：uboot启动过程中初始化板级硬件时不能出任何错误，只要有一个错误整个启动就终止，除了重启开发板没有任何办法。
init_sequence中的这些函数，都是board级别的各种硬件初始化。

板级硬件初始化

cpu_init 函数

cpu内部的初始化，我们在第一阶段进行的就是cpu内部初始化，所以这里是空的。

board_init

int board_init(void)
{
	DECLARE_GLOBAL_DATA_PTR;

#ifdef CONFIG_DRIVER_DM9000
	dm9000_pre_init();
#endif

	gd->bd->bi_arch_number = MACH_TYPE;
	gd->bd->bi_boot_params = (PHYS_SDRAM_1+0x100);

	return 0;
}

board_init在uboot/board/samsung/x210/x210.c中，是x210开发板相关的初始化。
DECLARE_GLOBAL_DATA_PTR在这里声明是为了后面使用gd方便。可以看出把gd的声明定义成一个宏的原因就是我们要到处去使用gd，因此就要到处声明，定义成宏比较方便。

网卡初始化。CONFIG_DRIVER_DM9000这个宏是x210_sd.h中定义的，这个宏用来配置开发板的网卡的。dm9000_pre_init函数就是对应的DM9000网卡的初始化函数。开发板移植uboot时，如果要移植网卡，主要的工作就在这里。

static void dm9000_pre_init(void)
{
    unsigned int tmp;
   
    SROM_BW_REG &= ~(0xf << 4);
    SROM_BW_REG |= (1<<7) | (1<<6) | (1<<5) | (1<<4);
    SROM_BC1_REG = ((0<<28)|(1<<24)|(5<<16)|(1<<12)|(4<<8)|(6<<4)|(0<<0));//uboot
    tmp = MP01CON_REG;
    tmp &=~(0xf<<4);
    tmp |=(2<<4);
    MP01CON_REG = tmp;
}

各个寄存器功能如下：

  SROM_BW_REG |= (1<<7) | (1<<6) | (1<<5) | (1<<4);

SROM_BW	Bit	说明
Tacs	[31:28]	nGCS前的地址设置：0000 = 0 clock
Tcos	[27:24]	nOE前芯片选择设置：0001 = 1 clocks
Tacc	[20:16]	访问周期：1001 = 6 clocks
Tcoh	[15:12]	在nOE上的芯片选择保持/Chip selection hold on nOE 0001 = 1 clocks
Tacp	[7:4]	页面模式访问周期：1010 = 6 clocks
PMC	[1:0]	设置页面模式：00 = Normal (1 data)，01 = 4 data

 SROM_BC1_REG = ((0<<28)|(1<<24)|(5<<16)|(1<<12)|(4<<8)|(6<<4)|(0<<0));//uboot

SROM_BCn	Bit	说明
ByteEnable1	[7]	nWBE/nBE(用于UB/LB)的内存 bank1控制 0=不使用UB/LB（XrnWBE[1:0]是专用的nWBE[1:0]）。 1=使用UB/LB（XrnWBE[1:0]是专用的nBE[1:0]）
WaitEnable1	[6]	存储器bank1的Wait启用控制 0 = 禁用 WAIT 1 = 启用 WAIT
AddrMode1	[5]	选择内存bank1的SROM ADDR基地址 0 = SROM_ADDR为半字基地址。 (srom_addr[22:0] <= haddr[23:1]) 1 = SROM_ADDR为字节基地址 (srom_addr[22:0] <= haddr[22:0]) 注意：当DataWidth1为 “0 “时，SROM_ADDR为字节基地址。(忽略了这一位)。
DataWidth1	[4]	存储器bank1的数据总线宽度控制 0=8位 1=16位

 tmp = MP01CON_REG; tmp |=(2<<4);

MP0_1CON	Bit	说明	初始值
MP0_1CON[1]	[7:4]	0010 = SROM_CSn[0]	0

这个函数中主要是网卡的GPIO和端口的配置，而不是驱动。因为网卡的驱动都是现成的正确的，移植的时候驱动是不需要改动的，关键是这里的基本初始化。因为这些基本初始化是硬件相关的。

interrupt_init

int interrupt_init(void)
{
	S5PC11X_TIMERS *const timers = S5PC11X_GetBase_TIMERS();

	/* use PWM Timer 4 because it has no output */
	/* prescaler for Timer 4 is 16 */
	timers->TCFG0 = 0x0f00;
	if (timer_load_val == 0) {
		/*
		 * for 10 ms clock period @ PCLK with 4 bit divider = 1/2
		 * (default) and prescaler = 16. Should be 10390
		 * @33.25MHz and  @ 66 MHz
		 */
		timer_load_val = get_PCLK() / (16 * 100);
	}

	/* load value for 10 ms timeout */
	lastdec = timers->TCNTB4 = timer_load_val;
	/* auto load, manual update of Timer 4 */
	timers->TCON = (timers->TCON & ~0x00700000) | TCON_4_AUTO | TCON_4_UPDATE;
	/* auto load, start Timer 4 */
	timers->TCON = (timers->TCON & ~0x00700000) | TCON_4_AUTO | COUNT_4_ON;
	timestamp = 0;

	return (0);
}

看名字函数是和中断初始化有关的，但是实际上不是，实际上这个函数是用来初始化定时器的（实际使用的是Timer4）。
裸机中讲过：210共有5个PWM定时器。其中Timer0-timer3都有一个对应的PWM信号输出的引脚。而Timer4没有引脚，无法输出PWM波形。Timer4在设计的时候就不是用来输出PWM波形的（没有引脚，没有TCMPB寄存器），这个定时器被设计用来做计时。
Timer4用来做计时时要使用到2个寄存器：TCNTB4、TCNTO4。
- TCNTB中存了一个数，这个数就是定时次数（每一次时间是由时钟决定的，其实就是由2级时钟分频器决定的）。我们定时时只需要把定时时间/基准时间=数，将这个数放入TCNTB中即可；
- 我们通过TCNTO寄存器即可读取时间有没有减到0，读取到0后就知道定的时间已经到了。
使用Timer4来定时，因为没有中断支持，所以CPU不能做其他事情同时定时，CPU只能使用轮询方式来不断查看TCNTO寄存器才能知道定时时间到了没。uboot中定时就是通过Timer4来实现定时的。所以uboot中定时时不能做其他事（考虑下，典型的就是bootdelay，bootdelay中实现定时并且检查用户输入是用轮询方式实现的，原理参考裸机中按键章节中的轮询方式处理按键）

interrupt_init函数将timer4设置为定时10ms。

访问寄存器的技巧

typedef volatile unsigned long	vu_long;
typedef vu_long		S5PC11X_REG32;
typedef struct {
    S5PC11X_REG32	TCNTB;
    S5PC11X_REG32	TCMPB;
    S5PC11X_REG32	TCNTO;
} /*__attribute__((__packed__))*/ S5PC11X_TIMER;
typedef struct {
    S5PC11X_REG32	TCFG0;
    S5PC11X_REG32	TCFG1;
    S5PC11X_REG32	TCON;
    S5PC11X_TIMER	ch[4];
    S5PC11X_REG32	TCNTB4;
    S5PC11X_REG32	TCNTO4;
} /*__attribute__((__packed__))*/ S5PC11X_TIMERS;

S5PC11X_TIMERS *const timers = S5PC11X_GetBase_TIMERS();

#define ELFIN_TIMER_BASE		0xE2500000
static inline S5PC11X_TIMERS * S5PC11X_GetBase_TIMERS(void)
{
    return (S5PC11X_TIMERS *)ELFIN_TIMER_BASE;
}

把寄存器的基地址作为定时器结构的指针赋值给定时器实例，使用是就可以通过 timers->TCFG0 = 0x0f00 的方式访问了

关键部位就是get_PCLK函数获取系统设置的PCLK_PSYS时钟频率

ulong get_PCLK(void)
{
    ulong hclk;
    uint div = CLK_DIV0_REG; // 0xE010_0300
    uint pclk_msys_ratio = ((div>>12) & 0x7);

    hclk = get_HCLK();	

    return hclk/(pclk_msys_ratio+1);
}

从《S5PV210_UM_REV1.1》P387 可知

CLK_DIV0	Bit	说明
PCLK_MSYS_RATIO	[14:12]	DIVPCLKM clock divider ratio</br>PCLK_MSYS = HCLK_MSYS / (PCLK_MSYS_RATIO + 1)
HCLK_MSYS_RATIO	[10:8]	DIVHCLKM clock divider ratio</br>HCLK_MSYS = ARMCLK / (HCLK_MSYS_RATIO + 1)
APLL_RATIO	[2:0]	DIVAPLL clock divider ratio</br>ARMCLK = MOUT_MSYS / (APLL_RATIO + 1)

ulong get_HCLK(void)
{
    ulong fclk;
    uint mux_stat = CLK_MUX_STAT0_REG; //0xE010_1100
    uint div,hclk_msys_ratio,apll_ratio;

    div = CLK_DIV0_REG;

    apll_ratio = ((div>>0) & 0x7);
    hclk_msys_ratio = ((div>>8)&0x7);

    switch ((mux_stat>>16) & 0x7) {
    case 2: //SCLKMPLL source
        fclk = get_MPLL_CLK();
        break;
    case 1:	//SCLKAPLL source
    default:
        fclk = get_FCLK();
        break;
    }

    return fclk/((apll_ratio+1)*(hclk_msys_ratio+1));
}

CLK_MUX_STAT0	Bit	说明	初始值
MUX_MSYS_SEL	[18:16]	Selection signal status of MUX_MSYS</br>(001:SCLKAPLL, 010:SCLKMPLL, 1xx: On changing)	1

这里应该走的是 get_MPLL_CLK()

ulong get_MPLL_CLK(void)
{
    return (get_PLLCLK(MPLL));
}

static ulong get_PLLCLK(int pllreg)
{
    ulong r, m, p, s;

    if (pllreg == APLL) {
        r = APLL_CON0_REG;
        m = (r>>16) & 0x3ff;
    } else if (pllreg == MPLL) {
        r = MPLL_CON_REG; // 0xE010_0108
        m = (r>>16) & 0x3ff;
    } else if (pllreg == EPLL) {
        r = EPLL_CON_REG;
        m = (r>>16) & 0x1ff;
    } else
        hang();

    p = (r>>8) & 0x3f;
    s = r & 0x7;

    if (pllreg == APLL) 
        s= s-1;
         
    return (m * (CONFIG_SYS_CLK_FREQ / (p * (1 << s))));
}

MPLL_CON	Bit	说明	初始值
MDIV	[25:16]	PLL M divide value	0x14D
PDIV	[13:8]	PLL P divide value	0x3
SDIV	[2:0]	PLL S divide value	0x1

$F_{OUT} = \dfrac{MDIV \times F_{IN}}{PDIV \times 2^{SDIV}}$

这里在uboot/include/autoconfig.h中定义了 $F_{IN}$ 的大小： CONFIG_SYS_CLK_FREQ=24000000

时钟源

fclk = get_MPLL_CLK()得到的是 MPLL 锁向环的输出 $FOUT_{MPLL}$ (图中左下角)，
然后输出的 $FOUT_{MPLL}$ 再经过 $DIV_{APLL}$ 和 $DIV_{HCLKM}$ 分频得到 HCLK_MSYS（图中右上角），即这里的 get_HCLK() 的返回值
得到的 HCLK_MSYS 再经过 $DIV_{PCLKM}$ 分频得到 PCLK_MSYS 时钟

然后设置TCFG0和TCFG1进行分频

timers->TCFG0 = 0x0f00; //Timer4 预分频系数为16

TCFG0	Bit	说明	初始值
Prescaler 1	[15:8]	Prescaler 1 value for Timer 2, 3 and 4	0x01
Prescaler 0	[7:0]	Prescaler 0 value for timer 0 and 1	0x01

然后计算出设置为10ms时需要向TCNTB中写入的值，将其写入TCNTB
```
if (timer_load_val == 0) {
    /*
     * for 10 ms clock period @ PCLK with 4 bit divider = 1/2
     * (default) and prescaler = 16. Should be 10390
     * @33.25MHz and  @ 66 MHz
     */
    timer_load_val = get_PCLK() / (16 * 100);
}
```
从《S5PV210_UM_REV1.1》P356 可以知道：

PCLK_MSYS = get_PCLK() = 100MHz，这里和数据手册中有偏差，数据手册中 Timer 是用的APB-PCLK，也就是 PCLK_PSYS 这个时钟是 66MHz 的。如果是 PCLK_PSYS 那么应该是用 get_PCLKP() 函数得到 PCLK_PSYS 的时钟，get_PCLK() 得到的是 PCLKK_MSYS 的时钟
然后设置为auto reload模式，然后开定时器开始计时

env_init

env_init，环境变量有关的初始化。
为什么有很多env_init函数，主要原因是uboot支持各种不同的启动介质（譬如norflash、nandflash、inand、sd卡·····），我们一般从哪里启动就会把环境变量env放到哪里。而各种介质存取操作env的方法都是不一样的。因此uboot支持了各种不同介质中env的操作方法。所以有好多个env_xx开头的c文件。实际使用的是哪一个要根据自己开发板使用的存储介质来定(通过x210_sd.h中配置的宏来决定谁被包含的），对于x210来说，我们应该看env_movi.c中的函数。
经过基本分析，这个函数只是对内存里维护的那一份uboot的env做了基本的初始化或者说是判定（判定里面有没有能用的环境变量）。当前因为我们还没进行环境变量从SD卡到DDR中的relocate，因此当前环境变量是不能用的。
在start_armboot()函数中（776行）调用env_relocate才进行环境变量从SD卡中到DDR中的重定位。重定位之后需要环境变量时才可以从DDR中去取，重定位之前如果要使用环境变量只能从SD卡中去读取。

init_baudrate

init_baudrate初始化串口通信的波特率
getenv_r函数用来读取环境变量的值。用getenv函数读取环境变量中“baudrate”的值（注意读取到的不是int型而是字符串类型），然后用simple_strtoul函数将字符串转成数字格式的波特率。
baudrate初始化时的规则是：先去环境变量中读取”baudrate”这个环境变量的值。如果读取成功则使用这个值作为环境变量，记录在gd->baudrate和gd->bd->bi_baudrate中；如果读取不成功则使用x210_sd.h中的的CONFIG_BAUDRATE的值作为波特率。从这可以看出：环境变量的优先级是很高的。

serial_init

int serial_init(void)
{
	serial_setbrg();
	return (0);
}

serial_init 初始化串口的
uboot中有很多个serial_init函数，我们使用的是uboot/cpu/s5pc11x/serial.c中的serial_init函数(vim 中使用 :ts 显示所有的 serial_init 函数, :tp, :tn 在同名函数中跳转)
进来后发现serial_init函数其实什么都没做。因为在汇编阶段串口已经被初始化过了，因此这里就不再进行硬件寄存器的初始化了。

console_init_f

console_init_f是console（控制台）的第一阶段初始化。_f表示是第一阶段初始化，_r表示第二阶段初始化。有时候初始化函数不能一次一起完成，中间必须要夹杂一些代码，因此将完整的一个模块的初始化分成了2个阶段。（我们的uboot中start_armboot的826行进行了console_init_r的初始化）
console_init_f在uboot/common/console.c中，仅仅是对gd->have_console设置为1而已，其他事情都没做。

display_banner

display_banner用来串口输出显示uboot的logo
display_banner中使用printf函数向串口输出了version_string这个字符串。那么上面的分析表示console_init_f并没有初始化好console怎么就可以printf了呢？
通过追踪printf的实现，发现printf->puts，而puts函数中会判断当前uboot中console有没有被初始化好。如果console初始化好了则调用fputs完成串口发送（这条线才是控制台）；如果console尚未初始化好则会调用serial_puts(再调用serial_putc直接操作串口寄存器进行内容发送)。
控制台也是通过串口输出，非控制台也是通过串口输出。究竟什么是控制台？和不用控制台的区别？控制台就是一个用软件虚拟出来的设备，这个设备有一套专用的通信函数（发送、接收···），控制台的通信函数最终会映射到硬件的通信函数中来实现。uboot中实际上控制台的通信函数是直接映射到硬件串口的通信函数中的，也就是说uboot中用没用控制器其实并没有本质差别。
但是在别的体系中，控制台的通信函数映射到硬件通信函数时可以用软件来做一些中间优化，譬如说缓冲机制。（操作系统中的控制台都使用了缓冲机制，所以有时候我们printf了内容但是屏幕上并没有看到输出信息，就是因为被缓冲了。我们输出的信息只是到了console的buffer中，buffer还没有被刷新到硬件输出设备上，尤其是在输出设备是LCD屏幕时）
U_BOOT_VERSION在uboot源代码中找不到定义，这个变量实际上是在makefile中定义的，然后在编译时生成的include/version_autogenerated.h中用一个宏定义来实现的。

print_cpuinfo

uboot启动过程中：

CPU:  S5PV210@1000MHz(OK)
        APLL = 1000MHz, HclkMsys = 200MHz, PclkMsys = 100MHz
        MPLL = 667MHz, EPLL = 96MHz
                       HclkDsys = 166MHz, PclkDsys = 83MHz
                       HclkPsys = 133MHz, PclkPsys = 66MHz
                       SCLKA2M  = 200MHz
Serial = CLKUART 

这些信息都是print_cpuinfo()打印出来的。

checkboard

checkboard 检查、确认开发板。这个函数的作用就是检查当前开发板是哪个开发板并且打印出开发板的名字。

init_func_i2c

#undef CONFIG_S3C64XX_I2C //没有I2C
#ifdef CONFIG_S3C64XX_I2C
#define CONFIG_HARD_I2C		1
#endif

#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
	init_func_i2c,
#endif

这个函数实际没有被执行，X210的uboot中并没有使用I2C。如果将来我们的开发板要扩展I2C来接外接硬件，则在x210_sd.h中配置相应的宏即可开启。

dram_init

int dram_init(void)
{
	DECLARE_GLOBAL_DATA_PTR;
	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;

#if defined(PHYS_SDRAM_2)
	gd->bd->bi_dram[1].start = PHYS_SDRAM_2;
	gd->bd->bi_dram[1].size = PHYS_SDRAM_2_SIZE;
#endif
}

这里没有初始化硬件 DDR，只是纯软件层面的设置，把 DDR 的起始地址和大小保存到boardinfo变量中，之后传给内核使用

display_dram_config

把DDR的信息打印出来，启动信息中的：（DRAM: 512 MB）就是在这个函数中打印出来的。uboot中有一个命令叫bdinfo，这个命令可以打印出gd->bd中记录的所有硬件相关的全局变量的值，因此可以得知DDR的配置信息。

DRAM bank   = 0x00000000
-> start    = 0x30000000
-> size     = 0x10000000
DRAM bank   = 0x00000001
-> start    = 0x40000000
-> size     = 0x10000000

init_sequence 总结

都是板级硬件的初始化以及gd、gd->bd中的数据结构的初始化。譬如：

网卡初始化
机器码（gd->bd->bi_arch_number）
内核传参DDR地址（gd->bd->bi_boot_params）
Timer4初始化为10ms一次
波特率设置（gd->bd->bi_baudrate和gd->baudrate）
console第一阶段初始化（gd->have_console设置为1）
打印uboot的启动信息
打印cpu相关设置信息
检查并打印当前开发板名字
DDR配置信息初始化（gd->bd->bi_dram）
打印DDR总容量

CFG_NO_FLASH

#ifndef CFG_NO_FLASH
	/* configure available FLASH banks */
	size = flash_init ();
	display_flash_config (size);
#endif /* CFG_NO_FLASH */

虽然NandFlash和NorFlash都是Flash，但是一般NandFlash会简称为Nand而不是Flash，一般讲Flash都是指的Norflash。这里2行代码是Norflash相关的。
flash_init执行的是开发板中对应的NorFlash的初始化、display_flash_config打印的也是NorFlash的配置信息（Flash: 8 MB就是这里打印出来的）。但是实际上X210中是没有Norflash的。所以着两行代码是可以去掉的（但是去掉着两行代码会导致别的地方工作不正常，需要花时间去移植调试)

CONFIG_VFD和CONFIG_LCD是显示相关的，这个是uboot中自带的LCD显示的软件架构。但是实际上我们用LCD而没有使用uboot中设置的这套软件架构，我们自己在后面自己添加了一个LCD显示的部分。

mem_malloc_init

static void mem_malloc_init (ulong dest_addr)
{
	mem_malloc_start = dest_addr;
	mem_malloc_end = dest_addr + CFG_MALLOC_LEN;
	mem_malloc_brk = mem_malloc_start;

	memset ((void *) mem_malloc_start, 0,
			mem_malloc_end - mem_malloc_start);
}

mem_malloc_init函数用来初始化uboot的堆管理器。
uboot中自己维护了一段堆内存，肯定自己就有一套代码来管理这个堆内存。有了这些东西uboot中你也可以malloc、free这套机制来申请内存和释放内存。我们在DDR内存中给堆预留了896KB的内存。

开发板独有初始化：mmc初始化

#if defined(CONFIG_X210)

	#if defined(CONFIG_GENERIC_MMC)
		puts ("SD/MMC:  ");
		mmc_exist = mmc_initialize(gd->bd);
		if (mmc_exist != 0) {
			puts ("0 MB\n");
		}
	#endif

	#if defined(CONFIG_CMD_NAND)
		puts("NAND:    ");
		nand_init();
	#endif

#endif /* CONFIG_X210 */

从536到768行为开发板独有的初始化。意思是三星用一套uboot同时满足了好多个系列型号的开发板，然后在这里把不同开发板自己独有的一些初始化写到了这里。用#if条件编译配合CONFIG_xxx宏来选定特定的开发板。
mmc_initialize看名字就应该是MMC相关的一些基础的初始化，其实就是用来初始化SoC内部的SD/MMC控制器的。函数在uboot/drivers/mmc/mmc.c里。
```
int mmc_initialize(bd_t *bis)
{
    struct mmc *mmc;
    int err;
   
    INIT_LIST_HEAD(&mmc_devices);
    cur_dev_num = 0;
   
    if (board_mmc_init(bis) < 0)
        cpu_mmc_init(bis);
    // 省略 ......
}
```
- INIT_LIST_HEAD(&mmc_devices); 通过链表构建了 mmc 设备表
- board_mmc_init() 和 cpu_mmc_init() 这样写的目的在于可以把 mmc 的初始化放在 board 级和 soc 级，有的 mmc 是在 board 上外界的芯片，而 x210 的 mmc 是集成在 SoC内部的，所以这里 board_mmc_init() 直接返回 -1
uboot中对硬件的操作（譬如网卡、SD卡···）都是借用的linux内核中的驱动来实现的，uboot根目录底下有个drivers文件夹，这里面放的全都是从linux内核中移植过来的各种驱动源文件。
mmc_initialize是具体硬件架构无关的一个MMC初始化函数，所有的使用了这套架构的代码都掉用这个函数来完成MMC的初始化。mmc_initialize中再调用board_mmc_init和cpu_mmc_init来完成具体的硬件的MMC控制器初始化工作。

(6)cpu_mmc_init在uboot/cpu/s5pc11x/cpu.c中，这里面又间接的调用了drivers/mmc/s3c_mmcxxx.c中的驱动代码来初始化硬件MMC控制器。这里面分层很多，分层的思想一定要有，否则完全就糊涂了。

env_relocate

void env_relocate (void)
{
	env_ptr = (env_t *)malloc(CFG_ENV_SIZE);
	if (gd->env_valid == 0) {
		puts ("*** Warning - bad CRC, using default environment\n\n");
		show_boot_progress (-60);
		set_default_env();
	}
	else {
		env_relocate_spec ();
	}
	gd->env_addr = (ulong)&(env_ptr->data);
}

首先通过 malloc 分配 CFG_ENV_SIZE = 4k 大小的堆内存用于放置环境变量
在第一次启动的时候，gd->env_valid == 0，通过 set_default_env() 设置默认的环境变量，这个默认的环境变量是 uchar default_environment[] 字符串数组，里面有 bootargs=CONFIG_BOOTARGS 默认变量值。之后 uboot 会把环境变量保存到 SD 卡的环境变量分区，以便下次启动的时候可以从 SD 卡读取

如果不是第一次启动，就会走 env_relocate_spec() 分支，这个函数在 /uboot/common/env_movi.c中，因为我们用的是 iNand

void env_relocate_spec (void)
{
    uint *magic = (uint*)(PHYS_SDRAM_1);
   
    if ((0x24564236 != magic[0]) || (0x20764316 != magic[1]))
        movi_read_env(virt_to_phys((ulong)env_ptr));
   
    if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
        return use_default();
}

这个函数是通过 movi_read_env() 从SD卡中读取环境变量

void movi_read_env(ulong addr)
{
    movi_read(raw_area_control.image[2].start_blk,
          raw_area_control.image[2].used_blk, addr);
}

这里 raw_area_control.image[2].start_blk 是 SD 卡环境变量分区的起始地址，used_blk是已经使用的块数

env_relocate是环境变量的重定位，完成从SD卡中将环境变量读取到DDR中的任务。
环境变量到底从哪里来？

SD卡中有一些（8个）独立的扇区作为环境变量存储区域的。但是我们烧录/部署系统时，我们只是烧录了uboot分区、kernel分区和rootfs分区，根本不曾烧录env分区。所以当我们烧录完系统第一次启动时ENV分区是空的，本次启动uboot尝试去SD卡的ENV分区读取环境变量时失败（读取回来后进行CRC校验时失败），我们uboot选择从uboot内部代码中设置的一套默认的环境变量出发来使用（这就是默认环境变量）；这套默认的环境变量在本次运行时会被读取到DDR中的环境变量中，然后被写入（也可能是你saveenv时写入，也可能是uboot设计了第一次读取默认环境变量后就写入）SD卡的ENV分区。然后下次再次开机时uboot就会从SD卡的ENV分区读取环境变量到DDR中，这次读取就不会失败了。
真正的从SD卡到DDR中重定位ENV的代码是在env_relocate_spec内部的movi_read_env完成的。

IP地址、MAC地址的确定

/* IP Address */
gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");

/* MAC Address */
{
    int i;
    ulong reg;
    char *s, *e;
    char tmp[64];

    i = getenv_r ("ethaddr", tmp, sizeof (tmp));
    s = (i > 0) ? tmp : NULL;

    for (reg = 0; reg < 6; ++reg) {
        gd->bd->bi_enetaddr[reg] = s ? simple_strtoul (s, &e, 16) : 0;
        if (s) s = (*e) ? e + 1 : e;
    }
}

开发板的IP地址是在gd->bd中维护的，来源于环境变量ipaddr。getenv函数用来获取字符串格式的IP地址，然后用string_to_ip将字符串格式的IP地址转成字符串格式的点分十进制格式。在环境变量中 MAC 地址的名称是 ethaddr，它的值是在 x210.h 中定义的 CONFIG_ETHADDR=00:40:5c:26:0a:5b
IP地址由4个0-255之间的数字组成，因此一个IP地址在程序中最简单的存储方法就是一个unsigend int。但是人类容易看懂的并不是这种类型，而是点分十进制类型（192.168.1.2）。这两种类型可以互相转换。
MAC 是由12个16进制的数据组成，如：00-16-EA-AE-3C-40就是一个MAC地址，其中前6位16进制数00-16-EA代表网络硬件制造商的编号，它由IEEE(电气与电子工程师协会)分配，而后6位16进制数AE-3C-40代表该制造商所制造的某个网络产品(如网卡)的系列号。只要不更改自己的MAC地址，MAC地址在世界是惟一的。

devices_init

devices_init是设备的初始化。这里的设备指的就是开发板上的硬件设备。放在这里初始化的设备都是驱动设备，这个函数本来就是从驱动框架中衍生出来的。uboot中很多设备的驱动是直接移植linux内核的（譬如网卡、SD卡），linux内核中的驱动都有相应的设备初始化函数。linux内核在启动过程中就有一个devices_init(名字不一定完全对，但是差不多)，作用就是集中执行各种硬件驱动的init函数。
uboot的这个函数其实就是从linux内核中移植过来的，它的作用也是去执行所有的从linux内核中继承来的那些硬件驱动的初始化函数。

jumptable_init

jumptable跳转表，本身是一个函数指针数组，里面记录了很多函数的函数名。实现一个函数指针到具体函数的映射关系，将来通过跳转表中的函数指针就可以执行具体的函数。这个其实就是在用C语言实现面向对象编程。
通过分析发现跳转表只是被赋值从未被引用，因此跳转表在uboot中根本就没使用。

console_init_r

int console_init_r (void)
{
    // 省略......

	puts ("\nIn:      ");
	if (stdio_devices[stdin] == NULL) {
		puts ("No input devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdin]->name);
	}

	puts ("Out:     ");
	if (stdio_devices[stdout] == NULL) {
		puts ("No output devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdout]->name);
	}

	puts ("Err:     ");
	if (stdio_devices[stderr] == NULL) {
		puts ("No error devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stderr]->name);
	}
}

uboot 启动过程的打印 In: Serial 就是出自这里

console_init_f是控制台的第一阶段初始化，console_init_r是第二阶段初始化。实际上第一阶段初始化并没有实质性工作，第二阶段初始化才进行了实质性工作。
console_init_r就是console的纯软件架构方面的初始化（给console相关的数据结构中填充相应的值），所以属于纯软件配置类型的初始化。
uboot的console实际上并没有干有意义的转化，它就是直接调用的串口通信的函数。所以用不用console实际并没有什么分别。（在linux内console就可以提供缓冲机制等不用console不能实现的东西）。

enable_interrupts

void enable_interrupts(void)
{
	return;
}

中断初始化代码。这里指的是CPSR中总中断标志位的使能。
因为我们uboot中没有使用中断，因此没有定义CONFIG_USE_IRQ宏，因此我们这里这个函数是个空壳子。

loadaddr、bootfile两个环境变量

/* Initialize from environment */
if ((s = getenv ("loadaddr")) != NULL) {
    load_addr = simple_strtoul (s, NULL, 16);
}
if ((s = getenv ("bootfile")) != NULL) {
    copy_filename (BootFile, s, sizeof (BootFile));
}

这两个环境变量都是内核启动有关的，在启动linux内核时会参考这两个环境变量的值。

board_late_init

int board_late_init (void)
{
	return 0;
}

这个函数就是开发板级别的一些初始化里比较晚的了，就是晚期初始化。晚期就是前面该初始化的都初始化过了，剩下的一些必须放在后面初始化的就在这里
对于X210来说，这个函数是空的。

eth_initialize

网卡相关的初始化。这里不是SoC与网卡芯片连接时SoC这边的初始化，而是网卡芯片本身的一些初始化。
对于X210（DM9000）来说，这个函数是空的。X210的网卡初始化在board_init函数中，网卡芯片的初始化在驱动中。

x210_preboot_init（LCD和logo显示）

extern void mpadfb_init(void);
int x210_preboot_init(void)
{
	mpadfb_init();
	return 1;
}

x210开发板在启动起来之前的一些初始化，以及LCD屏幕上的logo显示。

check menukey to update from sd

extern void update_all(void);
if(check_menu_update_from_sd()==0)//update mode
{
    puts ("[LEFT DOWN] update mode\n");
    run_command("fdisk -c 0",0);
    update_all();
}
else
    puts ("[LEFT UP] boot mode\n");

uboot启动的最后阶段设计了一个自动更新的功能。就是：我们可以将要升级的镜像放到SD卡的固定目录中，然后开机时在uboot启动的最后阶段检查升级标志（是一个按键。按键中标志为”LEFT”的那个按键，这个按键如果按下则表示update mode，如果启动时未按下则表示boot mode）。如果进入update mode则uboot会自动从SD卡中读取镜像文件然后烧录到iNand中；如果进入boot mode则uboot不执行update，直接启动正常运行。

static int check_menu_update_from_sd(void)
{
    unsigned int i;
    unsigned int reg;
   
    //GPH0_2
    reg = readl(GPH0CON);
    reg = reg & ~(0xf<<8) | (0x0<<8);
    writel(reg,GPH0CON);
   
    for(i=0;i<100;i++)
        udelay(500);
   
    reg = readl(GPH0DAT);
    reg = reg & (0x1<<2);
   
    if(reg)
        return 1;
    else //update mode
        return 0;
}

GPH0CON	Bit	说明	初始值
GPH0CON[2]	[11:8]	0000 = Input	0000

核心板原理图找到 GPH0_2 端口
底板原理图找到 GPH0_2/EINT_2 对应的电路图
把 GPH0_2 配置成输入端口
在读取这个端口的输入值

这种机制能够帮助我们快速烧录系统，常用于量产时用SD卡进行系统烧录部署。

main_loop

for (;;) {
    main_loop ();
}

解析器
开机倒数自动执行
命令补全

uboot启动2阶段总结

启动流程

第二阶段主要是对开发板级别的硬件、软件数据结构进行初始化。

重点函数

函数	子函数	子函数	功能
init_sequence	cpu_init	-	空
	board_init	dm9000_pre_init	网卡
		gd->bd->bi_arch_number	机器码
		gd->bd->bi_boot_params	内存传参地址
	interrupt_init		定时器
	env_init		环境变量
	init_baudrate		gd波特率
	serial_init		空
	console_init_f		空
	display_banner		打印启动信息
	print_cpuinfo		cpu时钟设置信息
	checkboard		检验开发板名字
	dram_init		gd数据结构中DDR信息
	display_dram_config		DDR配置信息
mem_malloc_init			初始化uboot自己维护的堆管理器的内存
mmc_initialize			inand/SD卡的SoC控制器和卡的初始化
env_relocate			环境变量重定位
gd->bd->bi_ip_addr			gd数据结构赋值
gd->bd->bi_enetaddr			gd数据结构赋值
devices_init			空的
jumptable_init			不用关注的
console_init_r			真正的控制台初始化
enable_interrupts			空的
loadaddr、bootfile			环境变量读出初始化全局变量
board_late_init			空的
eth_initialize			空的
x210_preboot_init			LCD初始化和显示logo
check_menu_update_from_sd			检查自动更新
main_loop			主循环

启动过程特征总结

第一阶段为汇编阶段、第二阶段为C阶段
第一阶段在SRAM中、第二阶段在DRAM中
第一阶段注重SoC内部、第二阶段注重SoC外部Board内部

uboot 编译下载步骤

uboot 编译步骤：

make distclean
make x210_sd_config
make

SD 卡烧写步骤：

进入sd_fusing目录下
make clean
make
插入sd卡，ls /dev/sd*得到SD卡在ubuntu中的设备号（一般是/dev/sdb，注意SD卡要连接到虚拟机ubuntu中，不要接到windows中）
./sd_fusing.sh /dev/sdb完成烧录（注意不是sd_fusing2.sh）

上篇uboot源码分析-第一汇编阶段

下篇uboot 如何启动内核