[uboot] （第五章）uboot流程——uboot启动流程

今天药忘吃喽~ 2022-11-17 03:24 299阅读 0赞

[https://blog.csdn.net/ooonebook/article/details/53070065][https_blog.csdn.net_ooonebook_article_details_53070065] 系列

以下例子都以project X项目tiny210（s5pv210平台,armv7架构）为例

\[uboot\] uboot流程系列：  
\[project X\] tiny210(s5pv210)上电启动流程（BL0-BL2）  
\[project X\] tiny210(s5pv210)从存储设备加载代码到DDR  
\[uboot\] （第一章）uboot流程——概述  
\[uboot\] （第二章）uboot流程——uboot-spl编译流程  
\[uboot\] （第三章）uboot流程——uboot-spl代码流程  
\[uboot\] （第四章）uboot流程——uboot编译流程  
\[uboot\] （番外篇）global\_data介绍  
\[uboot\] （番外篇）uboot relocation介绍

建议先看《\[project X\] tiny210(s5pv210)上电启动流程（BL0-BL2）》，根据例子了解一下上电之后的BL0\\BL1\\BL2阶段，以及各个阶段的运行位置，功能。  
建议可以和《\[uboot\] （番外篇）global\_data介绍》和《\[uboot\] （番外篇）uboot relocation介绍》结合起来看。

=================================================================================

一、uboot说明  
1、uboot要做的事情  
CPU初始刚上电的状态。需要小心的设置好很多状态，包括cpu状态、中断状态、MMU状态等等。其次，就是要根据硬件资源进行板级的初始化，代码重定向等等。最后，就是进入命令行状态，等待处理命令。  
在armv7架构的uboot，主要需要做如下事情

arch级的初始化

关闭中断，设置svc模式  
禁用MMU、TLB  
关键寄存器的设置，包括时钟、看门狗的寄存器  
板级的初始化

堆栈环境的设置  
代码重定向之前的板级初始化，包括串口、定时器、环境变量、I2C\\SPI等等的初始化  
进行代码重定向  
代码重定向之后的板级初始化，包括板级代码中定义的初始化操作、emmc、nand flash、网络、中断等等的初始化。  
进入命令行状态，等待终端输入命令以及对命令进行处理  
上述工作，也就是uboot流程的核心。

2、疑问  
在前面的文章中虽然已经说明了，在spl的阶段中已经对arch级进行了初始化了，为什么uboot里面还要对arch再初始化一遍？  
回答：spl对于启动uboot来说并不是必须的，在某些情况下，上电之后uboot可能在ROM上或者flash上开始执行而并没有使用spl。这些都是取决于平台的启动机制。因此uboot并不会考虑spl是否已经对arch进行了初始化操作，uboot会完整的做一遍初始化动作，以保证cpu处于所要求的状态下。

和spl在启动过程的差异在哪里？  
回答：以tiny210而言，前期arch的初始化流程基本上是一致的，出现本质区别的是在board\_init\_f开始的。

spl的board\_init\_f是由board自己实现相应的功能，例如tiny210则是在board/samsung/tiny210/board.c中。其主要实现了复制uboot到ddr中，并且跳转到uboot的对应位置上。一般spl在这里就可以完成自己的工作了。  
uboot的board\_init\_f是在common下实现的，其主要实现uboot relocate前的板级初始化以及relocate的区域规划，其还需要往下走其他初始化流程。  
3、代码入口  
project-X/u-boot/arch/arm/cpu/u-boot.lds

ENTRY(\_start)  
1  
所以uboot-spl的代码入口函数是\_start  
对应于路径project-X/u-boot/arch/arm/lib/vector.S的\_start，后续就是从这个函数开始分析。

二、代码整体流程  
1、首先看一下主枝干的流程（包含了arch级的初始化）  
在arch级初始化是和spl完全一致的  
\_start———–>reset————–>关闭中断  
………………………………|  
………………………………———->cpu\_init\_cp15———–>关闭MMU,TLB  
………………………………|  
………………………………———->cpu\_init\_crit————->lowlevel\_init————->关键寄存器的配置和初始化  
………………………………|  
………………………………———->\_main————–>进入板级初始化，具体看下面

2、板级初始化的流程  
\_main————–>board\_init\_f\_alloc\_reserve —————>堆栈、GD、early malloc空间的分配  
…………|  
…………————->board\_init\_f\_init\_reserve —————>堆栈、GD、early malloc空间的初始化  
…………|  
…………————->board\_init\_f —————>uboot relocate前的板级初始化以及relocate的区域规划  
…………|  
…………————->relocate\_code、relocate\_vectors —————>进行uboot和异常中断向量表的重定向  
…………|  
…………————->旧堆栈的清空  
…………|  
…………————->board\_init\_r —————>uboot relocate后的板级初始化  
…………|  
…………————->run\_main\_loop —————>进入命令行状态，等待终端输入命令以及对命令进行处理

三、arch级初始化代码分析  
1、\_start  
上述已经说明了\_start是整个uboot的入口，其代码如下：  
arch/arm/lib/vector.S

\_start:  
\#ifdef CONFIG\_SYS\_DV\_NOR\_BOOT\_CFG  
    .word   CONFIG\_SYS\_DV\_NOR\_BOOT\_CFG  
\#endif  
    b   reset  
1  
2  
3  
4  
5  
会跳转到reset中。

2、reset  
建议先参考\[kernel 启动流程\] （第二章）第一阶段之——设置SVC、关闭中断，了解一下为什么要设置SVC、关闭中断以及如何操作。

代码如下：  
arch/arm/cpu/armv7/start.S

.globl  reset  
    .globl  save\_boot\_params\_ret

reset:  
    /\* Allow the board to save important registers \*/  
    b   save\_boot\_params  
save\_boot\_params\_ret:  
    /\*  
     \* disable interrupts (FIQ and IRQ), also set the cpu to SVC32 mode,  
     \* except if in HYP mode already  
     \*/  
    mrs r0, cpsr  
    and r1, r0, \#0x1f       @ mask mode bits  
    teq r1, \#0x1a       @ test for HYP mode  
    bicne   r0, r0, \#0x1f       @ clear all mode bits  
    orrne   r0, r0, \#0x13       @ set SVC mode  
    orr r0, r0, \#0xc0       @ disable FIQ and IRQ  
    msr cpsr,r0  
@@ 以上通过设置CPSR寄存器里设置CPU为SVC模式，禁止中断  
@@ 具体操作可以参考《\[kernel 启动流程\] （第二章）第一阶段之——设置SVC、关闭中断》的分析

/\* the mask ROM code should have PLL and others stable \*/  
\#ifndef CONFIG\_SKIP\_LOWLEVEL\_INIT  
    bl  cpu\_init\_cp15  
@@ 调用cpu\_init\_cp15，初始化协处理器CP15,从而禁用MMU和TLB。  
@@ 后面会有一小节进行分析

bl  cpu\_init\_crit  
@@ 调用cpu\_init\_crit，进行一些关键的初始化动作，也就是平台级和板级的初始化  
@@ 后面会有一小节进行分析  
\#endif

bl  \_main  
@@ 跳转到主函数，也就是板级初始化函数  
@@ 下一节中进行说明。  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
3、cpu\_init\_cp15  
建议先参考\[kernel 启动流程\] （第六章）第一阶段之——打开MMU两篇文章的分析。  
cpu\_init\_cp15主要用于对cp15协处理器进行初始化，其主要目的就是关闭其MMU和TLB。  
代码如下(去掉无关部分的代码)：  
arch/arm/cpu/armv7/start.S

ENTRY(cpu\_init\_cp15)  
    /\*  
     \* Invalidate L1 I/D  
     \*/  
    mov r0, \#0          @ set up for MCR  
    mcr p15, 0, r0, c8, c7, 0   @ invalidate TLBs  
    mcr p15, 0, r0, c7, c5, 0   @ invalidate icache  
    mcr p15, 0, r0, c7, c5, 6   @ invalidate BP array  
    mcr     p15, 0, r0, c7, c10, 4  @ DSB  
    mcr     p15, 0, r0, c7, c5, 4   @ ISB  
@@ 这里只需要知道是对CP15处理器的部分寄存器清零即可。  
@@ 将协处理器的c7\\c8清零等等，各个寄存器的含义请参考《ARM的CP15协处理器的寄存器》

/\*  
     \* disable MMU stuff and caches  
     \*/  
    mrc p15, 0, r0, c1, c0, 0  
    bic r0, r0, \#0x00002000 @ clear bits 13 (--V-)  
    bic r0, r0, \#0x00000007 @ clear bits 2:0 (-CAM)  
    orr r0, r0, \#0x00000002 @ set bit 1 (--A-) Align  
    orr r0, r0, \#0x00000800 @ set bit 11 (Z---) BTB  
\#ifdef CONFIG\_SYS\_ICACHE\_OFF  
    bic r0, r0, \#0x00001000 @ clear bit 12 (I) I-cache  
\#else  
    orr r0, r0, \#0x00001000 @ set bit 12 (I) I-cache  
\#endif  
    mcr p15, 0, r0, c1, c0, 0  
@@ 通过上述的文章的介绍，我们可以知道cp15的c1寄存器就是MMU控制器  
@@ 上述对MMU的一些位进行清零和置位，达到关闭MMU和cache的目的，具体的话去看一下上述文章吧。

ENDPROC(cpu\_init\_cp15)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
4、cpu\_init\_crit  
cpu\_init\_crit，进行一些关键寄存器的初始化动。其代码核心就是lowlevel\_init，如下  
arch/arm/cpu/armv7/start.S

ENTRY(cpu\_init\_crit)  
    /\*  
     \* Jump to board specific initialization...  
     \* The Mask ROM will have already initialized  
     \* basic memory. Go here to bump up clock rate and handle  
     \* wake up conditions.  
     \*/  
    b   lowlevel\_init       @ go setup pll,mux,memory  
ENDPROC(cpu\_init\_crit)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
所以说lowlevel\_init就是这个函数的核心。  
lowlevel\_init一般是由板级代码自己实现的。但是对于某些平台来说，也可以使用通用的lowlevel\_init，其定义在arch/arm/cpu/lowlevel\_init.S中  
以tiny210为例，在移植tiny210的过程中，就需要在board/samsung/tiny210下，也就是板级目录下面创建lowlevel\_init.S，在内部实现lowlevel\_init。（其实只要实现了lowlevel\_init了就好，没必要说在哪里是实现，但是通常规范都是创建了lowlevel\_init.S来专门实现lowlevel\_init函数）。

在lowlevel\_init中，我们要实现如下：

检查一些复位状态  
关闭看门狗  
系统时钟的初始化  
内存、DDR的初始化  
串口初始化（可选）  
Nand flash的初始化  
下面以tiny210的lowlevel\_init为例（这里说明一下，当时移植tiny210的时候，是直接把kangear的这个lowlevel\_init.S文件拿过来用的）  
这部分代码和平台相关性很强，简单介绍一下即可  
board/samsung/tiny210/lowlevel\_init.S

lowlevel\_init:  
    push    \{lr\}

/\* check reset status  \*/

ldr r0, =(ELFIN\_CLOCK\_POWER\_BASE+RST\_STAT\_OFFSET)  
    ldr r1, \[r0\]  
    bic r1, r1, \#0xfff6ffff  
    cmp r1, \#0x10000  
    beq wakeup\_reset\_pre  
    cmp r1, \#0x80000  
    beq wakeup\_reset\_from\_didle  
@@ 读取复位状态寄存器0xE010\_a000的值，判断复位状态。

/\* IO Retention release \*/  
    ldr r0, =(ELFIN\_CLOCK\_POWER\_BASE + OTHERS\_OFFSET)  
    ldr r1, \[r0\]  
    ldr r2, =IO\_RET\_REL  
    orr r1, r1, r2  
    str r1, \[r0\]  
@@ 读取混合状态寄存器E010\_e000的值，对其中的某些位进行置位，复位后需要对某些wakeup位置1，具体我也没搞懂。

/\* Disable Watchdog \*/  
    ldr r0, =ELFIN\_WATCHDOG\_BASE    /\* 0xE2700000 \*/  
    mov r1, \#0  
    str r1, \[r0\]  
@@ 关闭看门狗

@@ 这里忽略掉一部分对外部SROM操作的代码

/\* when we already run in ram, we don't need to relocate U-Boot.  
     \* and actually, memory controller must be configured before U-Boot  
     \* is running in ram.  
     \*/  
    ldr r0, =0x00ffffff  
    bic r1, pc, r0      /\* r0 <- current base addr of code \*/  
    ldr r2, \_TEXT\_BASE      /\* r1 <- original base addr in ram \*/  
    bic r2, r2, r0      /\* r0 <- current base addr of code \*/  
    cmp     r1, r2                  /\* compare r0, r1                  \*/  
    beq     1f          /\* r0 == r1 then skip sdram init   \*/  
@@ 判断是否已经在SDRAM上运行了，如果是的话，就跳过以下两个对ddr初始化的步骤  
@@ 判断方法如下：  
@@ 1、获取当前pc指针的地址，屏蔽其低24bit，存放与r1中  
@@ 2、获取\_TEXT\_BASE（CONFIG\_SYS\_TEXT\_BASE）地址，也就是uboot代码段的链接地址，后续在uboot篇的时候会说明，并屏蔽其低24bit  
@@ 3、如果相等的话，就跳过DDR初始化的部分

/\* init system clock \*/  
    bl system\_clock\_init  
@@ 初始化系统时钟，后续有时间再研究一下具体怎么配置的

/\* Memory initialize \*/  
    bl mem\_ctrl\_asm\_init  
@@ 重点注意：在这里初始化DDR的！！！后续会写一篇文章说明一下s5pv210平台如何初始化DDR.  
@@ 其实，在tiny210的项目中，已经在spl里面对ddr初始化了一遍，这里还是又重新初始化了一遍，从实际测试结果来看，并不影响正常的使用。

1:  
    /\* for UART \*/  
    bl uart\_asm\_init  
@@ 串口初始化，到这里串口会打印出一个'O'字符，后续通过写字符到UTXH\_OFFSET寄存器中，就可以在串口上输出相应的字符。

bl tzpc\_init

\#if defined(CONFIG\_NAND)  
    /\* simple init for NAND \*/  
    bl nand\_asm\_init  
@@ 简单地初始化一下NAND flash，有可能BL2的镜像是在nand  flash上面的。  
\#endif

/\* Print 'K' \*/  
    ldr r0, =ELFIN\_UART\_CONSOLE\_BASE  
    ldr r1, =0x4b4b4b4b  
    str r1, \[r0, \#UTXH\_OFFSET\]  
@@ 再串口上打印‘K’字符，表示lowlevel\_init已经完成

pop \{pc\}  
@@ 弹出PC指针，即返回。  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
当串口中打印出‘OK’的字符的时候，说明lowlevel\_init已经执行完成。

三、板级初始化代码分析  
1、\_main  
板级初始化代码的入口就是\_main。从这里开始分析。  
建议可以和《\[uboot\] （番外篇）global\_data介绍》和《\[uboot\] （番外篇）uboot relocation介绍》结合起来看。  
代码如下，去除无关代码部分  
arch/arm/lib/crt0.S

ENTRY(\_main)

/\*  
 \* Set up initial C runtime environment and call board\_init\_f(0).  
 \*/  
    ldr sp, =(CONFIG\_SYS\_INIT\_SP\_ADDR)  
    bic sp, sp, \#7  /\* 8-byte alignment for ABI compliance \*/

mov r0, sp  
    bl  board\_init\_f\_alloc\_reserve  
    mov sp, r0  
    /\* set up gd here, outside any C code \*/  
    mov r9, r0  
    bl  board\_init\_f\_init\_reserve  
@@ 以上是堆栈、GD、early malloc空间的分配，具体参考《\[uboot\] （番外篇）global\_data介绍》

mov r0, \#0  
    bl  board\_init\_f  
@@ uboot relocate前的板级初始化以及relocate的区域规划，后续小节继续说明  
@@ 其中relocate区域规划也可以参考一下《\[uboot\] （番外篇）uboot relocation介绍》

/\*  
 \* Set up intermediate environment (new sp and gd) and call  
 \* relocate\_code(addr\_moni). Trick here is that we'll return  
 \* 'here' but relocated.  
 \*/

ldr sp, \[r9, \#GD\_START\_ADDR\_SP\] /\* sp = gd->start\_addr\_sp \*/  
    bic sp, sp, \#7  /\* 8-byte alignment for ABI compliance \*/  
    ldr r9, \[r9, \#GD\_BD\]        /\* r9 = gd->bd \*/  
    sub r9, r9, \#GD\_SIZE        /\* new GD is below bd \*/  
    adr lr, here  
    ldr r0, \[r9, \#GD\_RELOC\_OFF\]     /\* r0 = gd->reloc\_off \*/  
    add lr, lr, r0  
    ldr r0, \[r9, \#GD\_RELOCADDR\]     /\* r0 = gd->relocaddr \*/  
    b   relocate\_code  
here:  
/\*  
 \* now relocate vectors  
 \*/  
    bl  relocate\_vectors  
@@ GD、uboot、异常中断向量表的relocate，可以参考《\[uboot\] （番外篇）uboot relocation介绍》，这里不详细说明

/\* Set up final (full) environment \*/  
    bl  c\_runtime\_cpu\_setup /\* we still call old routine here \*/  
@@ 通过操作协处理器的c7寄存器来关闭Icache

ldr r0, =\_\_bss\_start    /\* this is auto-relocated! \*/  
    ldr r3, =\_\_bss\_end      /\* this is auto-relocated! \*/  
    mov r1, \#0x00000000     /\* prepare zero to clear BSS \*/  
    subs    r2, r3, r0      /\* r2 = memset len \*/  
    bl  memset  
@@ 因为堆栈段已经被relocate，所以这里需要清空原来的堆栈段的内容

bl coloured\_LED\_init  
    bl red\_led\_on  
@@ LED灯的初始化，可以不实现，想要实现的话，可以在board里重新实现一个函数定义。

/\* call board\_init\_r(gd\_t \*id, ulong dest\_addr) \*/  
    mov     r0, r9                  /\* gd\_t \*/  
    ldr r1, \[r9, \#GD\_RELOCADDR\] /\* dest\_addr \*/  
    /\* call board\_init\_r \*/  
    ldr pc, =board\_init\_r   /\* this is auto-relocated! \*/  
    /\* we should not return here. \*/  
@@ uboot relocate后的板级初始化，注意，uboot必须在这里就完成工作，或者在里面实现死循环，不应该返回。  
ENDPROC(\_main)  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
通过上述，有两个很重要的初始化函数，board\_init\_f和board\_init\_r，后续继续说明。

2、board\_init\_f  
代码如下：  
common/board\_f.c

void board\_init\_f(ulong boot\_flags)  
\{  
    gd->flags = boot\_flags;  
    gd->have\_console = 0;  
// 设置global\_data里面的一些标志位

if (initcall\_run\_list(init\_sequence\_f))  
        hang();  
// 调用initcall\_run\_list依次执行init\_sequence\_f函数数组里面的函数，initcall\_run\_list这里不深究  
// 一旦init\_sequence\_f的函数出错，会导致initcall\_run\_list返回不为0，而从卡掉  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
打开DEBUG宏之后，可以通过log观察哪些init函数被调用，如下log：

uboot log中有如下log：  
initcall: 23e005a4  
根据u-boot.map可以发现对应  
 .text.print\_cpuinfo  
                0x23e005a4        0x8 arch/arm/cpu/armv7/built-in.o  
                0x23e005a4                print\_cpuinfo  
也就是说print\_cpuinfo被initcall调用了。  
1  
2  
3  
4  
5  
6  
7  
所以uboot relocate之前的板级初始化的核心就是init\_sequence\_f中定义的函数了。  
如下，这里只做简单的说明，需要的时候再具体分析：

static init\_fnc\_t init\_sequence\_f\[\] = \{  
    setup\_mon\_len,  
// 计算整个镜像的长度gd->mon\_len  
    initf\_malloc,  
// early malloc的内存池的设定  
    initf\_console\_record,  
// console的log的缓存  
    arch\_cpu\_init,      /\* basic arch cpu dependent setup \*/  
// cpu的一些特殊的初始化  
    initf\_dm,  
    arch\_cpu\_init\_dm,  
    mark\_bootstage,     /\* need timer, go after init dm \*/  
    /\* TODO: can any of this go into arch\_cpu\_init()? \*/  
    env\_init,       /\* initialize environment \*/  
// 环境变量的初始化，后续会专门研究一下关于环境变量的内容  
    init\_baud\_rate,     /\* initialze baudrate settings \*/  
// 波特率的初始化  
    serial\_init,        /\* serial communications setup \*/  
// 串口的初始化  
    console\_init\_f,     /\* stage 1 init of console \*/  
// console的初始化  
    print\_cpuinfo,      /\* display cpu info (and speed) \*/  
// 打印CPU的信息  
    init\_func\_i2c,  
    init\_func\_spi,  
// i2c和spi的初始化

dram\_init,      /\* configure available RAM banks \*/  
// ddr的初始化，最重要的是ddr ram size的设置！！！！gd->ram\_size  
// 如果说uboot是在ROM、flash中运行的话，那么这里就必须要对DDR进行初始化  
//========================================  
    setup\_dest\_addr,  
    reserve\_round\_4k,  
    reserve\_trace,  
    setup\_machine,  
    reserve\_global\_data,  
    reserve\_fdt,  
    reserve\_arch,  
    reserve\_stacks,  
// ==以上部分是对relocate区域的规划，具体参考《\[uboot\] （番外篇）uboot relocation介绍》  
    setup\_dram\_config,  
    show\_dram\_config,  
    display\_new\_sp,  
    reloc\_fdt,  
    setup\_reloc,  
// relocation之后gd一些成员的设置  
    NULL,  
\};  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
注意，必须保证上述的函数都正确地返回0值，否则会导致hang。

3、board\_init\_r  
代码如下：  
common/board\_r.c

void board\_init\_r(gd\_t \*new\_gd, ulong dest\_addr)  
\{  
    if (initcall\_run\_list(init\_sequence\_r))  
        hang();  
// 调用initcall\_run\_list依次执行init\_sequence\_r函数数组里面的函数，initcall\_run\_list这里不深究  
// 一旦init\_sequence\_r的函数出错，会导致initcall\_run\_list返回不为0，而从卡掉

/\* NOTREACHED - run\_main\_loop() does not return \*/  
    hang();  
// uboot要求在这个函数里面终止一切工作，或者进入死循环，一旦试图返回，则直接hang。  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
所以uboot relocate之前的板级初始化的核心就是init\_sequence\_r中定义的函数了。  
如下，这里只做简单的说明，需要的时候再具体分析：  
common/board\_r.c

init\_fnc\_t init\_sequence\_r\[\] = \{  
    initr\_trace,  
// trace相关的初始化  
    initr\_reloc,  
// gd中一些关于relocate的标识的设置  
    initr\_reloc\_global\_data,  
// relocate之后，gd中一些的成员的重新设置  
    initr\_malloc,  
// malloc内存池的设置  
    initr\_console\_record,  
    bootstage\_relocate,  
    initr\_bootstage,  
\#if defined(CONFIG\_ARM) || defined(CONFIG\_NDS32)  
    board\_init, /\* Setup chipselects \*/  
// 板级自己需要的特殊的初始化函数，如board/samsung/tiny210/board.c中定义了board\_init这个函数  
\#endif  
    stdio\_init\_tables,  
    initr\_serial,  
// 串口初始化  
    initr\_announce,  
// 打印uboot运行位置的log  
    initr\_logbuffer,  
// logbuffer的初始化  
    power\_init\_board,  
\#ifdef CONFIG\_CMD\_NAND  
    initr\_nand,  
// 如果使用nand flash，那么这里需要对nand进行初始化  
\#endif  
\#ifdef CONFIG\_GENERIC\_MMC  
    initr\_mmc,  
// 如果使用emmc，那么这里需要对nand进行初始化  
\#endif  
    initr\_env,  
// 初始化环境变量  
    initr\_secondary\_cpu,  
    stdio\_add\_devices,  
    initr\_jumptable,  
    console\_init\_r,     /\* fully init console as a device \*/  
    interrupt\_init,  
// 初始化中断  
\#if defined(CONFIG\_ARM) || defined(CONFIG\_AVR32)  
    initr\_enable\_interrupts,  
// 使能中断  
\#endif  
    run\_main\_loop,  
// 进入一个死循环，在死循环里面处理终端命令。  
\};  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
最终，uboot运行到了run\_main\_loop，并且在run\_main\_loop进入命令行状态，等待终端输入命令以及对命令进行处理。  
到此，uboot流程也就完成了，后续会专门说明uboot的run\_main\_loop是怎么运行的。

[https_blog.csdn.net_ooonebook_article_details_53070065]: https://blog.csdn.net/ooonebook/article/details/53070065