本文以Board JZ2440(SMDK2410)的启动过程进行说明，u-boot选用u-boot-2015
1 概述
1.1 概述
CPU初始刚上电的状态。需要小心的设置好很多状态，包括cpu状态、中断状态、MMU状态等等。其次，就是要根据硬件资源进行板级的初始化，代码重定向等等。最后，就是进入命令行状态，等待处理命令。
在armv7架构的uboot，主要需要做如下事情
（1）arch级的初始化
- 关闭中断，设置svc模式
- 禁用MMU、TLB
- 关键寄存器的设置，包括时钟、看门狗的寄存器
（2）板级的初始化
- 堆栈环境的设置
- 代码重定向之前的板级初始化，包括串口、定时器、环境变量、I2C\SPI等等的初始化
- 进行代码重定向
- 代码重定向之后的板级初始化，包括板级代码中定义的初始化操作、emmc、nand flash、网络、中断等等的初始化。
（3）进入命令行状态，等待终端输入命令以及对命令进行处理
上述工作，也就是uboot流程的核心。
1.2 疑问
在spl的阶段中已经对arch级进行了初始化了，为什么uboot里面还要对arch再初始化一遍？
spl对于启动uboot来说并不是必须的，在某些情况下，上电之后uboot可能在ROM上或者flash上开始执行而并没有使用spl。这些都是取决于平台的启动机制。因此uboot并不会考虑spl是否已经对arch进行了初始化操作，uboot会完整的做一遍初始化动作，以保证cpu处于所要求的状态下。
和spl在启动过程的差异在哪里？
前期arch的初始化流程基本上是一致的，出现本质区别的是在board_init_f开始的。
spl的board_init_f是由board自己实现相应的功能。其主要实现了复制uboot到ddr中，并且跳转到uboot的对应位置上。一般spl在这里就可以完成自己的工作了。
uboot的board_init_f是在common下实现的，其主要实现uboot relocate前的板级初始化以及relocate的区域规划，其还需要往下走其他初始化流程。
1.3 编译说明
1 确定链接脚本文件：
uboot根目录下Makefile中的LDSCRIPT宏值，就是指定链接脚本（如：arch/arm/cpu/u-boot.lds）路径用的。
2 从脚本文件找入口：
在链接脚本中可以看到ENTRY()指定的入口，如：ENTRY(_start), _start就是入口（arch/arm/lib/vectors.S）
3 链接脚本简要分析：
/arch/arm/cpu/u-boot.lds
#include <config.h>
OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")@指定输出可执行文件是elf格式,32位ARM指令,小端
OUTPUT_ARCH(arm)@指定输出可执行文件的平台为ARM
ENTRY(_start)@入口函数 ,指定输出可执行文件的起始代码段为_start
SECTIONS
{
@指定可执行image文件的全局入口点，通常这个地址都放在ROM(flash)0x0位置。必须使编译器知道这个地址，通常都是修改此处来完成
. = 0x00000000;@起始地址 从0x0位置开始
. = ALIGN(4);@代码以4字节对齐
.text :@文本段
{
*(.__image_copy_start)@变量__image_copy_start 映像文件复制起始地址
*(.vectors)@异常向量表 .vectors标记的代码段
CPUDIR/start.o (.text*)@启动函数
*(.text*)@剩余的文本段
}
......@安全相关
. = ALIGN(4);
.rodata : { *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.rodata*))) }@ro数据段
. = ALIGN(4);
.data : {@RW数据段
*(.data*)
}
. = ALIGN(4);
. = .;
. = ALIGN(4);
.u_boot_list : {@？？？？
KEEP(*(SORT(.u_boot_list*)));
}
. = ALIGN(4);
.image_copy_end :
{
*(.__image_copy_end)@变量__image_copy_end
}
.rel_dyn_start :
{
*(.__rel_dyn_start)
}
.rel.dyn : {
*(.rel*)
}
.rel_dyn_end :
{
*(.__rel_dyn_end)
}
.end :
{
*(.__end)
}
_image_binary_end = .;
/*
* Deprecated: this MMU section is used by pxa at present but
* should not be used by new boards/CPUs.
*/
. = ALIGN(4096);
.mmutable : {
*(.mmutable)
}
/*
* Compiler-generated __bss_start and __bss_end, see arch/arm/lib/bss.c
* __bss_base and __bss_limit are for linker only (overlay ordering)
*/
.bss_start __rel_dyn_start (OVERLAY) : {
KEEP(*(.__bss_start));
__bss_base = .;
}
.bss __bss_base (OVERLAY) : {
*(.bss*)
. = ALIGN(4);
__bss_limit = .;
}
.bss_end __bss_limit (OVERLAY) : {
KEEP(*(.__bss_end));
}
.dynsym _image_binary_end : { *(.dynsym) }
.dynbss : { *(.dynbss) }
.dynstr : { *(.dynstr*) }
.dynamic : { *(.dynamic*) }
.plt : { *(.plt*) }
.interp : { *(.interp*) }
.gnu.hash : { *(.gnu.hash) }
.gnu : { *(.gnu*) }
.ARM.exidx : { *(.ARM.exidx*) }
.gnu.linkonce.armexidx : { *(.gnu.linkonce.armexidx.*) }
}
注意几个变量：
_start:程序启动入口地址处
__image_copy_start、__image_copy_end用于u-boot搬移本身image到指定的ddr地址处；
__rel_dyn_start、__rel_dyn_end用于重定位代码
__bss_start、__bss_end是bss段的开始、结束地址
上面的这几个变量会在arch\arm\lib\sections.c中使用，定义一些全局变量用于只是各个段的起始地址
//C文件中利用这种方式把一个变量或者函数标记到指定段。
char __bss_start[0] __attribute__((section(".__bss_start")));
char __bss_end[0] __attribute__((section(".__bss_end")));
char __image_copy_start[0] __attribute__((section(".__image_copy_start")));
char __image_copy_end[0] __attribute__((section(".__image_copy_end")));
char __rel_dyn_start[0] __attribute__((section(".__rel_dyn_start")));
char __rel_dyn_end[0] __attribute__((section(".__rel_dyn_end")));
char __secure_start[0] __attribute__((section(".__secure_start")));
char __secure_end[0] __attribute__((section(".__secure_end")));
char _end[0] __attribute__((section(".__end")));
在文件common/board_r.c中被调用：
static int initr_reloc_global_data(void)
{
#ifdef __ARM__
monitor_flash_len = _end - __image_copy_start;2 总体启动流程
2.1 总体流程
在arch级初始化
_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 —————>进入命令行状态，等待终端输入命令以及对命令进行处理2.2 启动流程主主干说明
1 vectors.S中第一条指令（分析文件arch/arm/lib/vectors.S）
_start: b reset
2 reset定义在文件arch/arm/cpu/arm920t/start.S中
start.S的执行流程如下图：
3 bl _main //调用c代码， _main实现在 /arch/arm/lib/crt0.S
_main执行流程图如下：
3 启动流程详解
3.1 中断向量表
分析文件：arch/arm/lib/vectors.S
.globl _start /*声明一个符号可被其它文件引用，相当于声明了一个全局变量，.globl与.global相同*/
_start:
b reset /* b是不带返回的跳转(bl是带返回的跳转)，意思是无条件直接跳转到reset标号处执行程序*/
ldr pc, _undefined_instruction /*未定义指令异常向量，ldr的作用是，将符号_undefined_instruction指向的地址的内容加载到pc*/
ldr pc, _software_interrupt /*软件中断向量*/
ldr pc, _prefetch_abort /*预取指令异常向量*/
ldr pc, _data_abort /*数据操作异常向量*/
ldr pc, _not_used /*未使用*/
ldr pc, _irq /*irq中断向量*/
ldr pc, _fiq /*fiq中断向量*/
.globl _undefined_instruction
.globl _software_interrupt
.globl _prefetch_abort
.globl _data_abort
.globl _not_used
.globl _irq
.globl _fiq
_undefined_instruction: .word undefined_instruction
_software_interrupt: .word software_interrupt
_prefetch_abort: .word prefetch_abort
_data_abort: .word data_abort
_not_used: .word not_used
_irq: .word irq
_fiq: .word fiq
.balignl 16,0xdeadbeef /*下面的代码开始16字节对齐，即当上段的代码运行完后不是16字节对齐，就填充0xdeadbeef，直到使下段的代码开始处16字节对齐。*/
//下面是占坑操作
/* IRQ stack memory (calculated at run-time) + 8 bytes, 不能确定堆栈指针地址，所以填充无效数字，当堆栈指针确定以后，将其加8填充到这里*/
.globl IRQ_STACK_START_IN
IRQ_STACK_START_IN:
.word 0x0badc0de
/*下面是IRQ中断，放了一个 IRQ_STACK_START 标号，标号内容为： 0x0badc0de ，此内容没有意义，只是为了占一个坑。程序刚刚运行，还没有进入初始化，根本不知道堆栈指针现在应该放在什么地方，所以一开始，作者做了一个小技巧，填充一个无效的数字，等初始化以后堆栈指针建立好后，再将实际的堆栈指针写到这里。*/
#ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */
.globl IRQ_STACK_START
IRQ_STACK_START:
.word 0x0badc0de
/* IRQ stack memory (calculated at run-time) */
.globl FIQ_STACK_START
FIQ_STACK_START:
.word 0x0badc0de
#endif /* CONFIG_USE_IRQ */3.2 关中断（FIQ IRQ），设置CPU为SVC32模式
文件位置：arch/arm/cpu/arm920t/start.S
功能：（1）设置SVC模式；（2）关看门狗，中断；（3）设置PLL
vectors.S中第一条指令
_start: b reset
arch/arm/cpu/arm920t/start.S
/*
*************************************************************************
*
* Startup Code (called from the ARM reset exception vector)
*
* do important init only if we don't start from memory!
* relocate armboot to ram
* setup stack
* jump to second stage
*
*************************************************************************
*/
.globl reset
reset:
/*
* set the cpu to SVC32 mode
*/
mrs r0, cpsr @将cpsr寄存器的内容传送到r0寄存器
bic r0, r0, #0x1f @工作模式位清零
orr r0, r0, #0xd3 @设置为SVC 模式
msr cpsr, r0 @将r0的值赋给cpsr
#ifdef CONFIG_S3C24X0
/* turn off the watchdog */
# if defined(CONFIG_S3C2400)
# define pWTCON 0x15300000
# define INTMSK 0x14400008 /* Interrupt-Controller base addresses */
# define CLKDIVN 0x14800014 /* clock divisor register */
#else
# define pWTCON 0x53000000
# define INTMSK 0x4A000008 /* Interrupt-Controller base addresses */
# define INTSUBMSK 0x4A00001C
# define CLKDIVN 0x4C000014 /* clock divisor register */
# endif
ldr r0, =pWTCON
mov r1, #0x0
str r1, [r0]
/*
* mask all IRQs by setting all bits in the INTMR - default
*/
mov r1, #0xffffffff
ldr r0, =INTMSK
str r1, [r0]
# if defined(CONFIG_S3C2410)
ldr r1, =0x3ff
ldr r0, =INTSUBMSK
str r1, [r0]
# endif
/* FCLK:HCLK:PCLK = 1:2:4 */
/* default FCLK is 120 MHz ! */
ldr r0, =CLKDIVN
mov r1, #3
str r1, [r0]
#endif /* CONFIG_S3C24X0 */
/*
* we do sys-critical inits only at reboot,
* not when booting from ram!
*/
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
bl cpu_init_crit
#endif
bl _main
/*------------------------------------------------------------------------------*/
.globl c_runtime_cpu_setup
c_runtime_cpu_setup:
mov pc, lr
3.3 跳转到cpu_init_crit
文件位置：arch/arm/cpu/arm920t/start.S
功能：（1）清空I-Cache、D-Cache;（2）关闭MMU Stuff及cachei;（3）跳转到lowlevel_init;
/*
*************************************************************************
*
* CPU_init_critical registers
*
* setup important registers
* setup memory timing
*
*************************************************************************
*/
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
cpu_init_crit:
/*
* flush v4 I/D caches
*/
mov r0, #0
mcr p15, 0, r0, c7, c7, 0 /* flush v3/v4 cache */
mcr p15, 0, r0, c8, c7, 0 /* flush v4 TLB */
/*
* disable MMU stuff and caches
*/
mrc p15, 0, r0, c1, c0, 0
bic r0, r0, #0x00002300 @ clear bits 13, 9:8 (--V- --RS)
bic r0, r0, #0x00000087 @ clear bits 7, 2:0 (B--- -CAM)
orr r0, r0, #0x00000002 @ set bit 2 (A) Align
orr r0, r0, #0x00001000 @ set bit 12 (I) I-Cache
mcr p15, 0, r0, c1, c0, 0
/*
* before relocating, we have to setup RAM timing
* because memory timing is board-dependend, you will
* find a lowlevel_init.S in your board directory.
*/
mov ip, lr
bl lowlevel_init
mov lr, ip
mov pc, lr
#endif /* CONFIG_SKIP_LOWLEVEL_INIT */lowlevel_init标号对应的源码：
（这个代码要初始化内存等，是和具体平台有关的，所以应该去对应平台的目录下找lowlevel_init.S文件board/samsung/smdk2410/lowlevel_init.S）
.globl lowlevel_init
lowlevel_init:
/* memory control configuration */
/* make r0 relative the current location so that it */
/* reads SMRDATA out of FLASH rather than memory ! */
ldr r0, =SMRDATA
ldr r1, =CONFIG_SYS_TEXT_BASE
sub r0, r0, r1
ldr r1, =BWSCON /* Bus Width Status Controller */
add r2, r0, #13*4
0:
ldr r3, [r0], #4
str r3, [r1], #4
cmp r2, r0
bne 0b
/* everything is fine now */
mov pc, lr
.ltorg
/* the literal pools origin */
SMRDATA:
.word (0+(B1_BWSCON<<4)+(B2_BWSCON<<8)+(B3_BWSCON<<12)+(B4_BWSCON<<16)+(B5_BWSCON<<20)+(B6_BWSCON<<24)+(B7_BWSCON<<28))
.word ((B0_Tacs<<13)+(B0_Tcos<<11)+(B0_Tacc<<8)+(B0_Tcoh<<6)+(B0_Tah<<4)+(B0_Tacp<<2)+(B0_PMC))
.word ((B1_Tacs<<13)+(B1_Tcos<<11)+(B1_Tacc<<8)+(B1_Tcoh<<6)+(B1_Tah<<4)+(B1_Tacp<<2)+(B1_PMC))
.word ((B2_Tacs<<13)+(B2_Tcos<<11)+(B2_Tacc<<8)+(B2_Tcoh<<6)+(B2_Tah<<4)+(B2_Tacp<<2)+(B2_PMC))
.word ((B3_Tacs<<13)+(B3_Tcos<<11)+(B3_Tacc<<8)+(B3_Tcoh<<6)+(B3_Tah<<4)+(B3_Tacp<<2)+(B3_PMC))
.word ((B4_Tacs<<13)+(B4_Tcos<<11)+(B4_Tacc<<8)+(B4_Tcoh<<6)+(B4_Tah<<4)+(B4_Tacp<<2)+(B4_PMC))
.word ((B5_Tacs<<13)+(B5_Tcos<<11)+(B5_Tacc<<8)+(B5_Tcoh<<6)+(B5_Tah<<4)+(B5_Tacp<<2)+(B5_PMC))
.word ((B6_MT<<15)+(B6_Trcd<<2)+(B6_SCAN))
.word ((B7_MT<<15)+(B7_Trcd<<2)+(B7_SCAN))
.word ((REFEN<<23)+(TREFMD<<22)+(Trp<<20)+(Trc<<18)+(Tchr<<16)+REFCNT)
.word 0x32
.word 0x30
.word 0x30
3.4 跳转到_main
文件：arch/arm/lib/crt0.S
设置并初始化C运行环境
（1）设置SP，C运行时会用到
（2）board_init_f(0)
（3）relocate_code/relocate_vectors/c_runtime_cpu_setup
（4）清空BSS
（5）board_init_r
/*
* This file handles the target-independent stages of the U-Boot
* start-up where a C runtime environment is needed. Its entry point
* is _main and is branched into from the target's start.S file.
*
* _main execution sequence is:
*
* 1. Set up initial environment for calling board_init_f().
* This environment only provides a stack and a place to store
* the GD ('global data') structure, both located in some readily
* available RAM (SRAM, locked cache...). In this context, VARIABLE
* global data, initialized or not (BSS), are UNAVAILABLE; only
* CONSTANT initialized data are available.
*
* 2. Call board_init_f(). This function prepares the hardware for
* execution from system RAM (DRAM, DDR...) As system RAM may not
* be available yet, , board_init_f() must use the current GD to
* store any data which must be passed on to later stages. These
* data include the relocation destination, the future stack, and
* the future GD location.
*
* (the following applies only to non-SPL builds)
*
* 3. Set up intermediate environment where the stack and GD are the
* ones allocated by board_init_f() in system RAM, but BSS and
* initialized non-const data are still not available.
*
* 4. Call relocate_code(). This function relocates U-Boot from its
* current location into the relocation destination computed by
* board_init_f().
*
* 5. Set up final environment for calling board_init_r(). This
* environment has BSS (initialized to 0), initialized non-const
* data (initialized to their intended value), and stack in system
* RAM. GD has retained values set by board_init_f(). Some CPUs
* have some work left to do at this point regarding memory, so
* call c_runtime_cpu_setup.
*
* 6. Branch to board_init_r().
*/
ENTRY(_main)
/*
* Set up initial C runtime environment and call board_init_f(0).
*/
/*
这里首先为调用board_init_f准备一个临时堆栈，CONFIG_SYS_INIT_SP_ADDR 这个宏就是cpu片上内存的高地址（片上内存的 大小减去GD_SIZE）。然后将堆栈初始的地址保存在r9，所以r9就是gd的起始地址，后面需要靠r9访问gd的成员。然后将r0赋值成0，r0就是要调用的board_init_f函数的第一个参数！
CONFIG_SYS_INIT_SP_ADDR = IRAM大小 - sizeof(GD)
*/
#if defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_STACK)
ldr sp, =(CONFIG_SPL_STACK)
#else
ldr sp, =(CONFIG_SYS_INIT_SP_ADDR)
#endif
bic sp, sp, #7 /* 8-byte alignment for ABI compliance */
sub sp, sp, #GD_SIZE /* allocate one GD above SP */
bic sp, sp, #7 /* 8-byte alignment for ABI compliance */
mov r9, sp /* GD is above SP */
mov r0, #0
bl board_init_f
#if ! defined(CONFIG_SPL_BUILD)
/*
* Set up intermediate environment (new sp and gd) and call
* relocate_code(addr_moni). Trick here is that we'll return
* 'here' but relocated.
*/
/*
*这段代码的主要功能就是将uboot搬移到内存的高地址去执行，为kernel腾出低端空间，防止kernel解压覆盖uboot。
• adr lr, here
• ldr r0, [r9, #GD_RELOC_OFF]
• add lr, lr, r0
• 功能就是，将relocate后的here标号的地址保存到lr寄存器，这样等到relocate完成后，就可以直接跳到relocate后的here标号去执行了。
*relocate_code函数的原理及流程，是 uboot 的重要代码，下面详解！
*/
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:
/*
*relocate完成后，uboot的代码被搬到了内存的顶部，所以必须重新设置异常向量表的
*地址，c_runtime_cpu_setup这个函数的主要功能就是重新设置异常向量表的地址。
*/
bl relocate_vectors
/* Set up final (full) environment */
bl c_runtime_cpu_setup /* we still call old routine here */
/*
*清空bss段。
*/
/*
*在relocate的过程中，并没有去搬移bss段。bss段是auto-relocated的！为什么？
*可以自己思考一下，又或许看完我后面介绍的relocate的原理后你会明白！
*/
ldr r0, =__bss_start /* this is auto-relocated! */
ldr r1, =__bss_end /* this is auto-relocated! */
mov r2, #0x00000000 /* prepare zero to clear BSS */
clbss_l:
cmp r0, r1 /* while not at end of BSS */
strlo r2, [r0] /* clear 32-bit BSS word */
addlo r0, r0, #4 /* move to next */
blo clbss_l
/*
*这两行代码无视之，点灯什么的，和这里要讲的uboot的原理及过程没有半毛钱关系。
*/
bl coloured_LED_init
bl red_led_on
/*
*将relocate后的gd的地址保存到r1，然后调用board_init_r函数，进入uboot的新天地！
*/
/* 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. */
#endif
ENDPROC(_main)
3.4.1 跳转到board_init_f(0)
功能：第一阶段启动
文件：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，而从卡掉
}打开DEBUG宏之后，可以通过log观察哪些init函数被调用：
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调用了。
所以uboot relocate之前的arch级初始化的核心就是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,
};
注意，必须保证上述的函数都正确地返回0值，否则会导致hang。
3.4.2 跳转 relocate_code
文件：arch/arm/lib/relocate.S
几点解释：
（1）uboot image在编译链接时已经链接到固定的地址处；
（2）image首先从flash上被copy到0地址处，然后根据链接地址重新将code搬移到链接时制定的DDR地址处；
（3）code搬移完成之后，PC会跳转到下一条指令地址处（已经是搬完code之后的新的地址），继续执行；
/*
* void relocate_code(addr_moni)
*
* This function relocates the monitor code.
*
* NOTE:
* To prevent the code below from containing references with an R_ARM_ABS32
* relocation record type, we never refer to linker-defined symbols directly.
* Instead, we declare literals which contain their relative location with
* respect to relocate_code, and at run time, add relocate_code back to them.
*/
ENTRY(relocate_code)
ldr r1, =__image_copy_start /* r1 <- SRC &__image_copy_start */
subs r4, r0, r1 /* r4 <- relocation offset */
beq relocate_done /* skip relocation */
ldr r2, =__image_copy_end /* r2 <- SRC &__image_copy_end */
copy_loop:
ldmia r1!, {r10-r11} /* copy from source address [r1] */
stmia r0!, {r10-r11} /* copy to target address [r0] */
cmp r1, r2 /* until source end address [r2] */
blo copy_loop
/*
* fix .rel.dyn relocations
*/
ldr r2, =__rel_dyn_start /* r2 <- SRC &__rel_dyn_start */
ldr r3, =__rel_dyn_end /* r3 <- SRC &__rel_dyn_end */
fixloop:
ldmia r2!, {r0-r1} /* (r0,r1) <- (SRC location,fixup) */
and r1, r1, #0xff
cmp r1, #23 /* relative fixup? */
bne fixnext
/* relative fix: increase location by offset */
add r0, r0, r4
ldr r1, [r0]
add r1, r1, r4
str r1, [r0]
fixnext:
cmp r2, r3
blo fixloop
relocate_done:
#ifdef __XSCALE__
/*
* On xscale, icache must be invalidated and write buffers drained,
* even with cache disabled - 4.2.7 of xscale core developer's manual
*/
mcr p15, 0, r0, c7, c7, 0 /* invalidate icache */
mcr p15, 0, r0, c7, c10, 4 /* drain write buffer */
#endif
/* ARMv4- don't know bx lr but the assembler fails to see that */
#ifdef __ARM_ARCH_4__
mov pc, lr
#else
bx lr
#endif
ENDPROC(relocate_code)3.4.3 relocate_vectors
文件：arch/arm/lib/relocate.S
说明：将uboot image开始的8个DWORD(即中断向量表)重新拷贝到0x0 或 VBAR
/*
* Default/weak exception vectors relocation routine
*
* This routine covers the standard ARM cases: normal (0x00000000),
* high (0xffff0000) and VBAR. SoCs which do not comply with any of
* the standard cases must provide their own, strong, version.
*/
.section .text.relocate_vectors,"ax",%progbits
.weak relocate_vectors
ENTRY(relocate_vectors)
#ifdef CONFIG_CPU_V7M
/*
* On ARMv7-M we only have to write the new vector address
* to VTOR register.
*/
ldr r0, [r9, #GD_RELOCADDR] /* r0 = gd->relocaddr */
ldr r1, =V7M_SCB_BASE
str r0, [r1, V7M_SCB_VTOR]
#else
#ifdef CONFIG_HAS_VBAR
/*
* If the ARM processor has the security extensions,
* use VBAR to relocate the exception vectors.
*/
ldr r0, [r9, #GD_RELOCADDR] /* r0 = gd->relocaddr */
mcr p15, 0, r0, c12, c0, 0 /* Set VBAR */
#else
/*
* Copy the relocated exception vectors to the
* correct address
* CP15 c1 V bit gives us the location of the vectors:
* 0x00000000 or 0xFFFF0000.
*/
ldr r0, [r9, #GD_RELOCADDR] /* r0 = gd->relocaddr */
mrc p15, 0, r2, c1, c0, 0 /* V bit (bit[13]) in CP15 c1 */
ands r2, r2, #(1 << 13)
ldreq r1, =0x00000000 /* If V=0 */
ldrne r1, =0xFFFF0000 /* If V=1 */
ldmia r0!, {r2-r8,r10}
stmia r1!, {r2-r8,r10}
ldmia r0!, {r2-r8,r10}
stmia r1!, {r2-r8,r10}
#endif
#endif
bx lr
ENDPROC(relocate_vectors)3.4.4 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。
}
所以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,
// 进入一个死循环，在死循环里面处理终端命令。
};
最终，uboot运行到了run_main_loop，并且在run_main_loop进入命令行状态，等待终端输入命令以及对命令进行处理。
cli---command line interface 命令行界面 命令行界面
4 run_main_loop函数
static int run_main_loop(void)
{
/* initialize uboot log */
init_write_log();
/* main_loop() can return to retry autoboot, if so just run it again */
for (;;)
main_loop();
return 0;
}
main_loop函数基本框架
main_loop()
>>>s = bootdelay_process();
>>>s = getenv("bootcmd");
>>>from GD
>>>autoboot_command(s)
>>>run_command_list(s, -1, 0);
>>>cli_simple_run_command_list()
while (*next) {
>>>cli_simple_run_command()
>>>cmd_process()
>>>cmd_call()
>>>result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
cmd_tbl_t/U_BOOT_CMD -----> do_cboot()
}
>>>cli_loop(); #进入命令行模式
>>> cli_simple_loop()
>>>run_command_repeatable()
>>>cli_simple_run_command()
>>>cmd_process()
到此，uboot流程也就完成了，main_loop函数的主要功能是实现命令的处理。
5 命令行的处理
5.1 概述
（1）uboot在执行完所有初始化程序之后，调用run_main_loop进入主循环，通过主循环进入了命令行模式。
（2）uboot把所有命令的数据结构都放在一个表格中，我们后续称之为命令表。表中的每一项代表着一个命令，其项的类型是cmd_tbl_t，这些命令在链接时会被链接到指定的段中，命令表是被定义在这个段中。
（3）命令行模式有两种简单的方式。正常模式是简单地获取串口数据、解析和处理命令。hush模式则是指命令的接收和解析使用busybox的hush工具，对应代码是hush.c
5.2 定义一个命令
文件：common/cmd_bootm.c
U_BOOT_CMD(
bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
"boot application image from memory", bootm_help_text
);
// bootm就是我们的命令字符串
// 在smdk2410.h中定义了最大参数数量是64
// #define CONFIG_SYS_MAXARGS 64 /* max number of command args */
// 1表示重复一次
// 对应命令处理函数是do_bootm
// usage字符串是对该命令的简短说明
// help字符串是bootm_help_text定义的字符串。5.2.1 U_BOOT_CMD实现
功能：定义一个cmd_tbl_t类型的变量，并在程序编译时链接到指定的段中。
文件：include/command.h
/*
* Command Flags:
*/
#define CMD_FLAG_REPEAT 0x0001 /* repeat last command */
#define CMD_FLAG_BOOTD 0x0002 /* command is from bootd */
#define CMD_FLAG_ENV 0x0004 /* command is from the environment */
#ifdef CONFIG_AUTO_COMPLETE
# define _CMD_COMPLETE(x) x,
#else
# define _CMD_COMPLETE(x)
#endif
#ifdef CONFIG_SYS_LONGHELP
# define _CMD_HELP(x) x,
#else
# define _CMD_HELP(x)
#endif
#define U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp) \
{ #_name, _maxargs, _rep, _cmd, _usage, \
_CMD_HELP(_help) _CMD_COMPLETE(_comp) }
#define U_BOOT_CMD_MKENT(_name, _maxargs, _rep, _cmd, _usage, _help) \
U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, NULL)
#define U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, _comp) \
ll_entry_declare(cmd_tbl_t, _name, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp);
#define U_BOOT_CMD(_name, _maxargs, _rep, _cmd, _usage, _help) \
U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, NULL)
其中最关键的函数ll_entry_declare 数据结构体类型：cmd_tbl_t
#define ll_entry_declare(_type, _name, _list) \
_type _u_boot_list_2_##_list##_2_##_name __aligned(4) \
__attribute__((unused, \
section(".u_boot_list_2_"#_list"_2_"#_name)))
文件：include/command.h
/*
* Monitor Command Table
*/
struct cmd_tbl_s {
char *name; /* Command Name */
int maxargs; /* maximum number of arguments */
int repeatable; /* autorepeat allowed? */
/* Implementation function */
int (*cmd)(struct cmd_tbl_s *, int, int, char * const []);
char *usage; /* Usage message (short) */
#ifdef CONFIG_SYS_LONGHELP
char *help; /* Help message (long) */
#endif
#ifdef CONFIG_AUTO_COMPLETE
/* do auto completion on the arguments */
int (*complete)(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
#endif
};
typedef struct cmd_tbl_s cmd_tbl_t; 展开后的变量定义如下：
ll_entry_declare(cmd_tbl_t, _name, cmd)
以bootm为例
_type=cmd_tbl_t
_name=bootm
_list=cmd
这里最终会转化为如下数据结构
cmd_tbl_t _u_boot_list_2_cmd_2_bootm=
{
_name=bootm，
_maxargs=CONFIG_SYS_MAXARGS，
_rep=1，
_cmd=do_bootm，
_usage="boot application image from memory"，
_help=bootm_help_text，
_comp=NULL，
}
并且这个数据结构给存放到了 .u_boot_list_2_cmd_2_bootm段中！！！和我们上述的完全一致。
5.2.2 do_bootm
具体解析见下节uboot boot kernel
5.3 命令的处理
5.3.1 基本流程
假设传进来的命令是cmd_name。
（1）获取命令表；
（2）从命令表中搜索和cmd_name匹配的项；
（3）执行对应项中的命令；
5.3.2 代码详解
通过find_cmd可以获取命令对应的命令表项cmd_tbl_t 。在命令表中（对应的段中）寻找与cmd_name相匹配的命令表项；
文件：common/command.c
enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
int *repeatable, ulong *ticks)
{
enum command_ret_t rc = CMD_RET_SUCCESS;
cmd_tbl_t *cmdtp;
/* Look up command in command table */
cmdtp = find_cmd(argv[0]); // 第一个参数argv[0]表示命令，调用find_cmd获取命令对应的表项cmd_tbl_t。
if (cmdtp == NULL) {
printf("Unknown command '%s' - try 'help'\n", argv[0]);
return 1;
}
/* found - check max args */
if (argc > cmdtp->maxargs)
rc = CMD_RET_USAGE; // 检测参数是否正常
/* If OK so far, then do the command */
if (!rc) {
if (ticks)
*ticks = get_timer(0);
rc = cmd_call(cmdtp, flag, argc, argv); // 调用cmd_call执行命令表项中的命令，成功的话需要返回0值
if (ticks)
*ticks = get_timer(*ticks); // 判断命令执行的时间
*repeatable &= cmdtp->repeatable; // 这个命令执行的重复次数存放在repeatable中的
}
if (rc == CMD_RET_USAGE)
rc = cmd_usage(cmdtp); // 命令格式有问题，打印帮助信息
return rc;
}
返回0表示执行成功，返回非0值表示执行失败。
后续需要执行一个命令的时候，直接调用cmd_process即可。后续我们我们分成“查找cmd对应的表项”、“执行对应表项中的命令”两部分进行说明.
1 查找cmd对应的表项 --- find_cmd
文件：common/command.c
cmd_tbl_t *find_cmd(const char *cmd)
{
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
// 获取命令表的地址，start表示指向命令表的指针，具体实现看后面
const int len = ll_entry_count(cmd_tbl_t, cmd);
// 获取命令表的长度，具体实现看后面
return find_cmd_tbl(cmd, start, len);
// 以命令表的指针和命令表的长度为参数，查找和cmd匹配的表项，也就是cmd_tbl_t结构，并返回给调用者。
}
文件：include/linker_lists.h
// 获取命令表的起始地址，也就是.u_boot_list_2_cmd_1的地址，
#define ll_entry_start(_type, _list) \
({ \
static char start[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_"#_list"_1"))); \
(_type *)&start; \
})
// 获取命令表的结束地址，也就是.u_boot_list_2_cmd_3的地址，
#define ll_entry_end(_type, _list) \
({ \
static char end[0] __aligned(4) __attribute__((unused, \
section(".u_boot_list_2_"#_list"_3"))); \
(_type *)&end; \
})
// 计算命令表的长度
#define ll_entry_count(_type, _list) \
({ \
_type *start = ll_entry_start(_type, _list); \
_type *end = ll_entry_end(_type, _list); \
unsigned int _ll_result = end - start; \
_ll_result; \
})
/* find command table entry for a command */
cmd_tbl_t *find_cmd_tbl(const char *cmd, cmd_tbl_t *table, int table_len)
{
#ifdef CONFIG_CMDLINE
cmd_tbl_t *cmdtp;
cmd_tbl_t *cmdtp_temp = table; /* Init value */
const char *p;
int len;
int n_found = 0;
if (!cmd)
return NULL;
/*
* Some commands allow length modifiers (like "cp.b");
* compare command name only until first dot.
*/
len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd);
for (cmdtp = table; cmdtp != table + table_len; cmdtp++) {
// 通过指针递增的方式，查找table中的每一个cmd_tbl_t
if (strncmp(cmd, cmdtp->name, len) == 0) {
if (len == strlen(cmdtp->name))
return cmdtp; /* full match */
// 如果是命令字符串和表项中的name完全匹配，包括长度一致的，则直接返回
cmdtp_temp = cmdtp; /* abbreviated command ? */
n_found++;
// 如果命令字符串和表项中的name的前面部分匹配的话（我们称为部分匹配），暂时保存下来，并且记录有几个这样的表项，主要是为了支持自动补全的功能
}
}
if (n_found == 1) { /* exactly one match */
return cmdtp_temp;
// 如果部分匹配的表项是唯一的话，则可以将这个表项返回，主要是为了支持自动补全的功能
}
#endif /* CONFIG_CMDLINE */
return NULL; /* not found or ambiguous command */
}
2 执行对应表项中的命令——cmd_call
通过调用cmd_call可以执行命令表项cmd_tbl_t 中的命令
文件：common/command.c
static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int result;
result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
// 直接执行命令表项cmd_tbl_t 中的cmd命令处理函数
if (result)
debug("Command failed, result=%d\n", result);
// 命令返回非0值时，报错
return result;
}
6 uboot boot kernel
文件：common/cmd_bootm.c
U_BOOT_CMD(
bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
"boot application image from memory", bootm_help_text
);
do_bootm参数说明：
当执行‘bootm 0x20008000 0x21000000 0x22000000’命令时，do_bootm会被调用
int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
cmdtp：传递的是bootm的命令表项指针，也就是_u_boot_list_2_cmd_2_bootm的指针
argc=4,argv[0]="bootm", argv[1]=0x20008000, arv[2]=0x21000000, argv[3]=0x22000000
/*******************************************************************/
/* bootm - boot application image from image in memory */
/*******************************************************************/
int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
/* determine if we have a sub command */
argc--; argv++;
if (argc > 0) {
char *endp;
simple_strtoul(argv[0], &endp, 16);
/* endp pointing to NULL means that argv[0] was just a
* valid number, pass it along to the normal bootm processing
*
* If endp is ':' or '#' assume a FIT identifier so pass
* along for normal processing.
*
* Right now we assume the first arg should never be '-'
*/
if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
return do_bootm_subcommand(cmdtp, flag, argc, argv);
}
// 以上会判断是否有子命令，这里我们不管
// 到这里，参数中的bootm参数会被去掉，
// 也就是当'bootm 0x20008000 0x21000000 0x22000000'时
// argc=3, argv[0]=0x20008000 , argv[1]=0x21000000, argv[2]=0x22000000
// 当‘bootm 0x30000000’时
// argc=1, argv[0]=0x30000000
return do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START |
BOOTM_STATE_FINDOS | BOOTM_STATE_FINDOTHER |
BOOTM_STATE_LOADOS |
BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
BOOTM_STATE_OS_GO, &images, 1);
// 最终对调用到do_bootm_states，在do_bootm_states中执行的操作如states标识所示：
// BOOTM_STATE_START
// BOOTM_STATE_FINDOS
// BOOTM_STATE_FINDOTHER
// BOOTM_STATE_LOADOS
// BOOTM_STATE_OS_PREP
// BOOTM_STATE_OS_FAKE_GO
// BOOTM_STATE_OS_GO
}
所以bootm的核心是do_bootm_states，以全局变量bootm_headers_t images作为do_bootm_states的参数。6.1 do_bootm_states函数
do_bootm_states
>>>bootm_start(cmdtp, flag, argc, argv)//填充image中的verify和lmb
>>>bootm_find_os(cmdtp, flag, argc, argv)//填充image中的os和ep，不管是Legacy-uImage还是FIT-uImage，最终解析出来要得到的都是这两个成员
>>>bootm_find_other(cmdtp, flag, argc, argv)//实现rd_start, rd_end，ft_addr和initrd_end,不管是Legacy-uImage还是FIT-uImage，最终解析出来要得到的都是这两个成员
>>>ret = bootm_load_os(images, &load_end, 0);
>>>bootm_os_get_boot_func()//用于获取到对应操作系统的启动函数，被存储到boot_fn 中
>>>boot_fn(BOOTM_STATE_OS_PREP, argc, argv, images);
>>>boot_selected_os(argc, argv, BOOTM_STATE_OS_GO,images, boot_fn);下面对着几个函数的功能做一个简要的说明：
（1）bootm_start & bootm_find_os & bootm_find_other
主要负责解析环境变量、参数、uImage，来填充bootm_headers_t images这个数据结构。
typedef struct bootm_headers {
image_info_t os; /* os image info */
ulong ep; /* entry point of OS */
ulong rd_start, rd_end;/* ramdisk start/end */
char *ft_addr; /* flat dev tree address */
ulong ft_len; /* length of flat device tree */
ulong initrd_start;
ulong initrd_end;
ulong cmdline_start;
ulong cmdline_end;
bd_t *kbd;
int verify; /* getenv("verify")[0] != 'n' */
#ifdef CONFIG_LMB
struct lmb lmb; /* for memory mgmt */
#endif
}（2）bootm_load_os
在bootm_load_os中，会对kernel镜像进行load到对应的位置上，并且如果kernel镜像是被mkimage压缩过的，那么会先经过解压之后再进行load。（这里要注意，这里的压缩和Image压缩成zImage并不是同一个，而是uboot在Image或者zImage的基础上进行的压缩！！！）
static int bootm_load_os(bootm_headers_t *images, unsigned long *load_end,
int boot_progress)
{
image_info_t os = images->os;
ulong load = os.load; // kernel要加载的地址
ulong blob_start = os.start;
ulong blob_end = os.end;
ulong image_start = os.image_start; // kernel实际存在的位置
ulong image_len = os.image_len; // kernel的长度
bool no_overlap;
void *load_buf, *image_buf;
int err;
load_buf = map_sysmem(load, 0);
image_buf = map_sysmem(os.image_start, image_len);
// 调用bootm_decomp_image，对image_buf的镜像进行解压缩，并load到load_buf上
err = bootm_decomp_image(os.comp, load, os.image_start, os.type,
load_buf, image_buf, image_len,
CONFIG_SYS_BOOTM_LEN, load_end);
。。。
}结果上述步骤之后，kernel镜像就被load到对应位置上了。
（3）bootm_os_get_boot_func
bootm_os_get_boot_func用于获取到对应操作系统的启动函数，被存储到boot_fn 中。
int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
int states, bootm_headers_t *images, int boot_progress)
{
...
boot_fn = bootm_os_get_boot_func(images->os.os);
...
}
boot_os_fn *bootm_os_get_boot_func(int os)
{
return boot_os[os];
// 根据操作系统类型获得到对应的操作函数
}
static boot_os_fn *boot_os[] = {
...
#ifdef CONFIG_BOOTM_LINUX
[IH_OS_LINUX] = do_bootm_linux,
#endif
}
可以看出最终启动linux的核心函数是do_bootm_linux。
（4）boot_selected_os及其它
另外几个函数最终也是调用到boot_fn，对应linux也就是do_bootm_linux，所以这里不在说明了。
6.2 do_bootm_linux函数
文件：arch/arm/lib/bootm.c
int do_bootm_linux(int flag, int argc, char * const argv[],
bootm_headers_t *images)
{
/* No need for those on ARM */
if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
return -1;
// 当flag为BOOTM_STATE_OS_PREP，则说明只需要做准备动作boot_prep_linux
if (flag & BOOTM_STATE_OS_PREP) {
boot_prep_linux(images);
return 0;
}
// 当flag为BOOTM_STATE_OS_GO ，则说明只需要做跳转动作
if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
boot_jump_linux(images, flag);
return 0;
}
boot_prep_linux(images); // 以全局变量bootm_headers_t images为参数传递给boot_prep_linux
boot_jump_linux(images, flag);// 以全局变量bootm_headers_t images为参数传递给 boot_jump_linux
return 0;
}boot_prep_linux用于实现跳转到linux前的准备动作；boot_jump_linux用于跳转到linux中。
都是以全局变量bootm_headers_t images为参数，这样就可以直接获取到前面步骤中得到的kernel镜像、ramdisk以及fdt的信息了。
6.2.1 boot_prep_linux函数
首先要说明一下LMB的概念。LMB是指logical memory blocks，主要是用于表示内存的保留区域，主要有fdt的区域，ramdisk的区域等等。
boot_prep_linux主要的目的是修正LMB，并把LMB填入到fdt中。
实现如下：
static void boot_prep_linux(bootm_headers_t *images)
{
char *commandline = getenv("bootargs");
if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len) {
#ifdef CONFIG_OF_LIBFDT
debug("using: FDT\n");
if (image_setup_linux(images)) {
printf("FDT creation failed! hanging...");
hang();
}
#endif
}这里没有深入学习image_setup_linux，等后续有需要的话再进行深入。
6.2.2 boot_jump_linux函数
文件：arch/arm/lib/bootm.c
static void boot_jump_linux(bootm_headers_t *images, int flag)
{
unsigned long machid = gd->bd->bi_arch_number; // 从bd中获取machine-id，
char *s;
void (*kernel_entry)(int zero, int arch, uint params); // kernel入口函数，也就是kernel的入口地址，对应kernel的_start地址。
unsigned long r2;
int fake = (flag & BOOTM_STATE_OS_FAKE_GO); // 伪跳转，并不真正地跳转到kernel中
kernel_entry = (void (*)(int, int, uint))images->ep;
// 将kernel_entry设置为images中的ep（kernel的入口地址），后面直接执行kernel_entry也就跳转到了kernel中了
// 这里要注意这种跳转的方法
debug("## Transferring control to Linux (at address %08lx)" \
"...\n", (ulong) kernel_entry);
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
announce_and_cleanup(fake);
// 把images->ft_addr（fdt的地址）放在r2寄存器中
if (IMAGE_ENABLE_OF_LIBFDT && images->ft_len)
r2 = (unsigned long)images->ft_addr;
else
r2 = gd->bd->bi_boot_params;
if (!fake) {
kernel_entry(0, machid, r2);
// 这里通过调用kernel_entry，就跳转到了images->ep中了，也就是跳转到kernel中了，具体则是kernel的_start符号的地址。
// 参数0则传入到r0寄存器中，参数machid传入到r1寄存器中，把images->ft_addr（fdt的地址）放在r2寄存器中
// 满足了kernel启动的硬件要求
}
}
到这里，经过kernel_entry之后就跳转到kernel环境中了。
6198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
