当前位置：首页 > news >正文

riscv uboot 启动流程分析 - SPL启动流程

news 2024/10/24 21:08:07

分析uboot 启动流程
硬件：启明智显推出M4核心板（https://gitee.com/qiming-zhixian/m4-openwrt）

1.U-boot和SPL概述

U-Boot 分为 uboot-spl 和 uboot 两个组成部分。SPL 是 Secondary Program Loader 的简称，第二阶段程序加载器。对于嵌入式SOC(System On Chip)芯片来说，芯片内本身含有SRAM用于将闪存中的bootloader(uboot)加载到RAM来运行，但由于片内RAM大小限制，加载不了完整的U-boot程序，所以需要在加载uboot之前加载一个精简版的SPL，SPL可用来初始化DDR等一些必须的外设，然后在把完整的Uboot加载到DDR里面运行。

系统冷启动过程中经历的不同阶段有：

BROM(Boot ROM) -> SPL -> OpenSBI -> U-Boot -> Kernel

因此在 U-Boot SPL 运行之前，BROM 已经对系统进行了基本的初始化。

下载代码：

# 下载主工程代码
git clone https://gitee.com/qiming-zhixian/m4-openwrt.git
# 下载feeds软件包
cd m4-openwrt
git clone https://gitee.com/qiming-zhixian/zx-feeds.git

1.1. 启动参数

http://doc.panel-tag.cn/m4/op/index.html

了解启动参数，首先要了解启动流程。正常启动过程包含几种跳转，每一种跳转都会有相应的参数传递。

1.1.1.正常启动流程
在这里插入图片描述
正常启动过程详细介绍：

BROM 根据启动方式去定位 SPL 位置，初始化对应非易失性存储器，加载 SPL 到 SRAM 上，BROM 运行在 M-Mode;
SPL 被执行；
SPL PBP 部分代码初始化 DRAM，之后初始化非易失性存储器；
SPL 加载u-boot.itb(包含 OpenSBI,U-Boot,DTB)到 DRAM；
OpenSBI被执行，切换到S-Mode；
U-Boot 被执行；
U-Boot加载设备树DTB，环境变量ENV；
U-Boot加载Kernel，DTB到DRAM；
Kernel被执行，加载DTB；
Rootfs被执行，切换到U-Mode,整个系统启动完成;

1.1.2. BROM 传递的参数

BROM 跳转到 SPL 时传递的参数：
在这里插入图片描述
OpenSBI 跳转到 U-Boot 时传递的参数：

传递参数结构体定义如下，具体实现可参考：

m4-openwrt/package/boot/uboot-m4/src/arch/riscv/include/asm/arch-zx/m4/boot_param.h:
37 union boot_params {38   /*39    * Save registers. Later's code use these register value to:40    * 1. Get parameters from previous boot stage41    * 2. Return to Boot ROM in some condition42    *43    * For SPL:44    *      a0 is boot param45    *      a1 is private data address46    * For U-Boot:47    *      a0 is hartid from opensbi48    *      a1 is opensbi param49    *      a2 is opensbi param50    *      a3 is boot param from SPL51    */52   unsigned long regs[22];53   struct {54     unsigned long a[8];  /* a0 ~ a7 */55     unsigned long s[12]; /* s0 ~ s11 */56     unsigned long sp;57     unsigned long ra;58   } r;59 };

1.1.2. BROM 参数获取的过程

无论是 SPL 还是 U-Boot，在执行时的第一步动作就是保存这些启动参数，具体实现可参考 arch/riscv/cpu/start.S

 43 _start:44   /* Allow the board to save important registers */45   j save_boot_params46 save_boot_params_ret:47 #if CONFIG_IS_ENABLED(RISCV_MMODE)48   csrr  a0, CSR_MHARTID49 #endif

save_boot_params 的实现在源文件 arch/riscv/mach-zx/lowlevel_init.S

 10 #ifdef CONFIG_32BIT11 #define LREG      lw12 #define SREG      sw13 #define REGBYTES    414 #define RELOC_TYPE    R_RISCV_3215 #define SYM_INDEX   0x816 #define SYM_SIZE    0x1017 #else18 #define LREG      ld19 #define SREG      sd20 #define REGBYTES    821 #define RELOC_TYPE    R_RISCV_6422 #define SYM_INDEX   0x2023 #define SYM_SIZE    0x1824 #endif28 ENTRY(save_boot_params)29   la  t0, boot_params_stash30   SREG  a0, REGBYTES * 0(t0)31   SREG  a1, REGBYTES * 1(t0)32   SREG  a2, REGBYTES * 2(t0)33   SREG  a3, REGBYTES * 3(t0)34   SREG  a4, REGBYTES * 4(t0)35   SREG  a5, REGBYTES * 5(t0)36   SREG  a6, REGBYTES * 6(t0)37   SREG  a7, REGBYTES * 7(t0)38   SREG  s0, REGBYTES * 8(t0)39   SREG  s1, REGBYTES * 9(t0)40   SREG  s2, REGBYTES * 10(t0)41   SREG  s3, REGBYTES * 11(t0)42   SREG  s4, REGBYTES * 12(t0)43   SREG  s5, REGBYTES * 13(t0)44   SREG  s6, REGBYTES * 14(t0)45   SREG  s7, REGBYTES * 15(t0)46   SREG  s8, REGBYTES * 16(t0)47   SREG  s9, REGBYTES * 17(t0)48   SREG  s10, REGBYTES * 18(t0)49   SREG  s11, REGBYTES * 19(t0)50   SREG  sp, REGBYTES * 20(t0)51   SREG  ra, REGBYTES * 21(t0)52   j save_boot_params_ret53 ENDPROC(save_boot_params)

传递的参数被保存在全局变量 boot_params_stash 中，SPL 或者 U-Boot 可从中获取相关信息。在保存参数时，不仅将 a0,a1 寄存器保存起来，还将其他重要寄存器一起保存。

arch/riscv/mach-zx/m4/boot_param.c:
13 /*14  * Save boot parameters and context when save_boot_params is called.15  */16 union boot_params boot_params_stash __section(".data");

1.1.3. 参数获取接口

无论是在 SPL 还是在 U-Boot 中，都可以通过下列接口获取上一级引导程序传递的参数。

enum boot_reason aic_get_boot_reason(void);
enum boot_device aic_get_boot_device(void);

相关的定义可参考文件：

arch/riscv/include/asm/arch-zx/m4/boot_param.h
arch/riscv/mach-zx/m4/boot_param.c

1.2.SPL 阶段

ZX 平台上的 SPL(Secondary Program Loader) 是第一级引导程序(FSBL, First Stage Boot Loader)，同时也是第二级程序加载器。SPL 运行在 SRAM 中，其最重要的任务有两个：

完成 DDR，并且使能 Cache
加载和验证 U-Boot

SPL RISCV 的启动整体流程

_start // arch/riscv/cpu/start.S
|-> save_boot_params // arch/riscv/mach-zx/lowlevel_init.S
|   // BROM 跳转到 SPL 执行的时候，传递了一些参数，这里首先需要将这些参数保存起来
|
|-> csrw    MODE_PREFIX(ie), zero // Disable irq
|-> li      t1, CONFIG_SPL_STACK // 设置sp寄存器
|-> jal     board_init_f_alloc_reserve // common/init/board_init.c
|   // 预留初始 HEAP 的空间
|   // 预留 GD 全局变量的空间
|
|-> jal     board_init_f_init_reserve
|   // common/init/board_init.c, init gd area
|   // 此时 gd 在 SPL STACK 中。
|
|-> jal     icache_enable // arch/riscv/cpu/c906/cache.c 使能指令高速缓存
|-> jal     dcache_enable // 使能数据高速缓存
|
|-> jal     debug_uart_init // drivers/serial/ns16550.c
| // 初始化调试串口，如果使能
|
|-> board_init_f // arch/riscv/lib/spl.c
|   |-> spl_early_init() // common/spl/spl.c
|       |-> spl_common_init(setup_malloc = true) // common/spl/spl.c
|           |-> fdtdec_setup();  // lib/fdtdec.c 获取dtb的地址，并验证合法性
|           | // 只对带有“u-boot,dm-pre-reloc”属性节点进行解析，初始化驱动模型的根节点，扫描设备树创建udevice,uclass
|           |-> dm_init_and_scan(!CONFIG_IS_ENABLED(OF_PLATDATA)); // drivers/core/root.c
|               |-> dm_init(); // driver model, initiate virtual root driver
|               |   |-> INIT_LIST_HEAD(DM_UCLASS_ROOT_NON_CONST); // 初始化uclass链表
|               |   |-> device_bind_by_name()
|               |   |   |   // drivers/core/device.c
|               |   |   |   // 加载"root_driver"name, gd->dm_root
|               |   |   |-> lists_driver_lookup_name()
|               |   |   |   |-> ll_entry_start(struct driver, driver); // 获取driver table起始位置
|               |   |   |   |-> ll_entry_count(struct driver, driver); // 获取driver table长度
|               |   |   |   // drivers/core/lists.c
|               |   |   |   // 采用 U_BOOT_DRIVER(name) 声明的 driver，从driver table中获取struct driver数据
|               |   |   |
|               |   |   |   // 初始化udevice 与对应的uclass,driver绑定
|               |   |   |-> device_bind_common(); // drivers/core/device.c
|               |   |       |-> uclass_get(&uc)
|               |   |       |   |-> uclass_find(id); // 判断对应的uclass是否存在
|               |   |       |   |-> uclass_add(id, ucp); // 如果不存在就创建
|               |   |       |       |-> lists_uclass_lookup(id); // 获取uclass_driver结构体数据
|               |   |       |-> uclass_bind_device(dev) // uclass绑定udevice drivers/core/uclass.c
|               |   |       |-> drv->bind(dev)  // driver绑定udevice
|               |   |       |-> parent->driver->child_post_bind(dev)
|               |   |       |-> uc->uc_drv->post_bind(dev)
|               |   |
|               |   |-> device_probe(gd->dm_root) // drivers/core/device.c
|               |       |-> uclass_resolve_seq(dev) // 通过dtb解析获得设备差异数据
|               |       |-> uclass_pre_probe_device(dev); // probe前操作
|               |       |-> drv->probe(dev); // 执行driver的probe操作
|               |       |-> uclass_post_probe_device(dev); // probe后操作
|               |
|               |-> dm_scan(pre_reloc_only);
|                   |   // 扫描和绑定由 U_BOOT_DEVICE 声明的驱动。
|                   |   // 一般用在 SPL OF_PLATDATA 的情况
|                   |-> dm_scan_plat(pre_reloc_only);
|                   |   |-> lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only);
|                   |       |-> bind_drivers_pass(parent, pre_reloc_only);
|                   |           |-> device_bind_by_name();
|                   |
|                   |-> dm_extended_scan(pre_reloc_only);
|                   |   |-> dm_scan_fdt(pre_reloc_only); // 扫描设备树并与设备驱动建立联系
|                   |   |   |-> dm_scan_fdt_node(gd->dm_root, ofnode_root(), pre_reloc_only); //扫描设备树并绑定root节点下的设备
|                   |   |       |-> ofnode_first_subnode(parent_node) // 获取设备树的第一个子节点
|                   |   |       |-> ofnode_next_subnode(node) // 遍历所有的子节点
|                   |   |       |-> ofnode_is_enabled(node) // 判断设备树的子节点是否使能
|                   |   |       |-> lists_bind_fdt(parent, node, NULL, pre_reloc_only); // 绑定设备树节点，创建新的udevicd drivers/core/lists.c
|                   |   |           |-> ofnode_get_property(node, "compatible", &compat_length); // 获取compatible
|                   |   |           |-> driver_check_compatible() // 和driver比较compatible值
|                   |   |           |-> device_bind_with_driver_data() // 创建一个设备并绑定到driver drivers/core/device.c
|                   |   |               |-> device_bind_common() // 创建初始化udevice 与对应的uclass,driver绑定
|                   |   |
|                   |   | // /chosen /clocks /firmware 一些节点本身不是设备，但包含一些设备，遍历其包含的设备
|                   |   |-> dm_scan_fdt_ofnode_path(nodes[i], pre_reloc_only);
|                   |       |-> ofnode_path(path); // 找到节点下包含的设备
|                   |       |-> dm_scan_fdt_node(gd->dm_root, node, pre_reloc_only);
|                   |
|                   |-> dm_scan_other(pre_reloc_only);
|                   |   // 扫描使用者自定义的节点 nothing
|
|-> spl_clear_bss // arch/riscv/cpu/start.S
|-> spl_relocate_stack_gd   // 切换stack 和 gd 到dram空间
|-> board_init_r()    // common/spl/spl.c|-> spl_set_bd()  // board data info|   // 设置完 bd 之后，才能 enable d-cache|-> mem_malloc_init()|   // init heap|   //  - CONFIG_SYS_SPL_MALLOC_START|   //  - CONFIG_SYS_SPL_MALLOC_SIZE>||-> spl_init|   |-> spl_common_init|       // 由于前面已经调用了 spl_early_init,|       // 这里不再调用 spl_common_init||-> timer_init(); // lib/time.c nothing|-> spl_board_init(); // arch/riscv/mach-zx/spl.c nothing||-> initr_watchdog  // enable watchdog，如果使能|-> dram_init_banksize(); // 如果使能|-> board_boot_order() // common/spl/spl.c|   |-> spl_boot_device(); // arch/riscv/mach-zx/spl.c|       |-> aic_get_boot_device(); // arch/riscv/mach-zx/boot_param.c|           // 从 boot param 中获取启动介质信息||-> boot_from_devices(spl_boot_list)|   |-> spl_ll_find_loader()  // 根据boot device找到spl_load_image指针|   |       // 这里可能是各种介质的 load image 函数|   |       // SPL_LOAD_IMAGE_METHOD() 定义的 Loader|   |       // 可能是 MMC/SPI/BROM/...|   ||   |-> spl_load_image  // 以emmc启动为例|       |-> spl_mmc_load_image  // common/spl/spl_mmc.c|           |-> spl_mmc_load // 具体可看后面的流程||-> spl_perform_fixups  // vendor hook，用于修改device-tree传递参数|-> spl_board_prepare_for_boot  // vendor hook, 可不实现|-> jump_to_image_no_args   // 跳转到u-boot执行

1.2.1.SPL 启动具体分析

SPL 入口函数：

Because SPL images normally have a different text base, one has to be configured by defining CONFIG_SPL_TEXT_BASE. The linker script has to be defined with CONFIG_SPL_LDSCRIPT.

SPL的入口是由链接脚本决定：

arch/riscv/Kconfig：
251 config SPL_LDSCRIPT
252   default "arch/riscv/cpu/u-boot-spl.lds"

arch/riscv/cpu/u-boot-spl.lds：

  9 MEMORY { .spl_mem : ORIGIN = IMAGE_TEXT_BASE, LENGTH = IMAGE_MAX_SIZE }10 MEMORY { .bss_mem : ORIGIN = CONFIG_SPL_BSS_START_ADDR, \11         LENGTH = CONFIG_SPL_BSS_MAX_SIZE }1213 OUTPUT_ARCH("riscv")14 ENTRY(_start)1516 SECTIONS17 {18   . = ALIGN(4);19   .text : {20     arch/riscv/cpu/start.o  (.text)21     *(.text*)22   } > .spl_mem2324   . = ALIGN(4);25   .rodata : {26     *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.rodata*)))27   } > .spl_mem2829   . = ALIGN(4);30   .data : {31     *(.data*)32   } > .spl_mem33   . = ALIGN(4);

启动流程：

第一阶段 arch/riscv/cpu/start.S 文件。
第二阶段启动阶段中，会重点涉及到位于 common/board_r.c 的 board_init_f 函数和位于 common/board_r.c 文件的的 board_init_r 函数。board_init_f 会初始化必要的板卡和 global_data 结构体，然后调用 board_init_r 进行下一阶段的板卡初始化工作。board_init_r 运行结束之后，会调用位于 common/main.c 的 main_loop() 函数进行。

1.2.1.1.第一阶段 start.S

1).代码最开始，根据cpu的bit定义了一套后续使用的宏定义。

 19 #ifdef CONFIG_32BIT20 #define LREG      lw21 #define SREG      sw22 #define REGBYTES    423 #define RELOC_TYPE    R_RISCV_3224 #define SYM_INDEX   0x825 #define SYM_SIZE    0x1026 #else27 #define LREG      ld28 #define SREG      sd29 #define REGBYTES    830 #define RELOC_TYPE    R_RISCV_6431 #define SYM_INDEX   0x2032 #define SYM_SIZE    0x1833 #endif

2).入口_start

主要做的事情：

读取控制状态寄存器(CSR) mhartid 的值到a0寄存器；
保存上一级boot 传递的参数；
设置异常入口函数、关中断；

.section .text
.globl _start
_start:     /* 链接脚本里面指定了这里是uboot的入口 */
#if CONFIG_IS_ENABLED(RISCV_MMODE)csrr	a0, CSR_MHARTID
#endif

RISCV_MMODE 就是 machine mode

arch/riscv/Kconfig：
choiceprompt "Run Mode"default RISCV_MMODEconfig RISCV_MMODEbool "Machine"helpChoose this option to build U-Boot for RISC-V M-Mode.config RISCV_SMODEbool "Supervisor"helpChoose this option to build U-Boot for RISC-V S-Mode.

csrr a0, CSR_MHARTID 读取控制状态寄存器(CSR) mhartid 的值到a0寄存器。CSR_MHARTID 存储了当前硬件线程（hart）的ID。

保存上一级boot 传递的参数：

 64   /* save hart id and dtb pointer */65   mv  tp, a066   mv  s1, a1

设置异常入口函数、关中断：

 68   la  t0, trap_entry69   csrw  MODE_PREFIX(tvec), t07071   /* mask all interrupts */72   csrw  MODE_PREFIX(ie), zero

设置堆栈，地址对齐,每个core都会分配自己的堆栈地址，挑选一个主core进行初始化，其他的core wait在wait_for_gd_init.

 91 /*92  * Set stackpointer in internal/ex RAM to call board_init_f93  */94 call_board_init_f:95   li  t0, -16    /* -16 的16进制就是 0xffff fff0 ，用来对齐使用的 */96 #if defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_STACK)   /* 这里是给SPL使用的 */97   li  t1, CONFIG_SPL_STACK98 #else99   li  t1, CONFIG_SYS_INIT_SP_ADDR
100 #endif
101   and sp, t1, t0     /* 设置堆栈指针，并16byte对齐，force 16 byte alignment */
102
103 call_board_init_f_0:
104   mv  a0, sp
105   jal board_init_f_alloc_reserve  /* 从sp高地址开始预留一段内存给global_data使用，返回的是减去预留后的地址，也就是gd的首地址*/
106
107   /* setup stack ，设置新的堆栈，根据core的数量进行划分 */
108 #ifdef CONFIG_SMP
109   /* tp: hart id */
110   slli  t0, tp, CONFIG_STACK_SIZE_SHIFT   /* tp保存的是当前core id，根据core id 进行sp的划分，每一个core分一块内存用作sp */
111   sub sp, a0, t0
112 #else
113   mv  sp, a0
114 #endif
115 ...

设置icache和dcache：

186   /* Enable cache */
187   jal icache_enable
188   jal dcache_enable

设置参数调用board_init_f 进行环境的初始化，后面会详细讲board_init_f

194   mv  a0, zero    /* a0 <-- boot_flags = 0 *//* * 如果是uboot，那么会调用common下面的board_f.c里面的函数，spl可能不是这个，要看编译配置 * 这个函数会顺序执行init_sequence_f数组里面的函数*/
195   la  t5, board_init_f
196   jalr  t5      /* jump to board_init_f()，执行完后，跳到本文件里面的relocate_code继续往下走 */

board_init_f ：

arch/riscv/lib/spl.c：22 __weak void board_init_f(ulong dummy)23 {24   int ret;2526   ret = spl_early_init();27   if (ret)28     panic("spl_early_init() failed: %d\n", ret);2930   arch_cpu_init_dm();3132   preloader_console_init();3334   ret = spl_board_init_f();35   if (ret)36     panic("spl_board_init_f() failed: %d\n", ret);37 }

下面是SPL专用的代码，主要用于清bss，设置堆栈，最后跳到board_init_r.


198 #ifdef CONFIG_SPL_BUILD
199 spl_clear_bss:
200   la  t0, __bss_start
201   la  t1, __bss_end
202   beq t0, t1, spl_stack_gd_setup
203
204 spl_clear_bss_loop:
205   SREG  zero, 0(t0)
206   addi  t0, t0, REGBYTES
207   blt t0, t1, spl_clear_bss_loop
208
209 spl_stack_gd_setup:
210   jal spl_relocate_stack_gd
211
212   /* skip setup if we did not relocate */
213   beqz  a0, spl_call_board_init_r
214   mv  s0, a0
215
216   /* setup stack on main hart */
217 #ifdef CONFIG_SMP
218   /* tp: hart id */
219   slli  t0, tp, CONFIG_STACK_SIZE_SHIFT
220   sub sp, s0, t0
221 #else
222   mv  sp, s0
223 #endif
224
225   /* set new stack and global data pointer on secondary harts */
226 spl_secondary_hart_stack_gd_setup:
227   la  a0, secondary_hart_relocate
228   mv  a1, s0
229   mv  a2, s0
230   mv  a3, zero
231   jal smp_call_function
232
233   /* hang if relocation of secondary harts has failed */
234   beqz  a0, 1f
235   mv  a1, a0
236   la  a0, secondary_harts_relocation_error
237   jal printf
238   jal hang
239
240   /* set new global data pointer on main hart */
241 1:  mv  gp, s0
242
243 spl_call_board_init_r:
244   mv  a0, zero
245   mv  a1, zero
246   jal board_init_r
247 #endif

board_init_r：

|-> board_init_r()    // common/spl/spl.c|-> spl_set_bd()  // board data info|   // 设置完 bd 之后，才能 enable d-cache|-> mem_malloc_init()|   // init heap|   //  - CONFIG_SYS_SPL_MALLOC_START|   //  - CONFIG_SYS_SPL_MALLOC_SIZE>||-> spl_init|   |-> spl_common_init|       // 由于前面已经调用了 spl_early_init,|       // 这里不再调用 spl_common_init||-> timer_init(); // lib/time.c nothing|-> spl_board_init(); // arch/riscv/mach-zx/spl.c nothing||-> initr_watchdog  // enable watchdog，如果使能|-> dram_init_banksize(); // 如果使能|-> board_boot_order() // common/spl/spl.c|   |-> spl_boot_device(); // arch/riscv/mach-zx/spl.c|       |-> aic_get_boot_device(); // arch/riscv/mach-zx/boot_param.c|           // 从 boot param 中获取启动介质信息||-> boot_from_devices(spl_boot_list)|   |-> spl_ll_find_loader()  // 根据boot device找到spl_load_image指针|   |       // 这里可能是各种介质的 load image 函数|   |       // SPL_LOAD_IMAGE_METHOD() 定义的 Loader|   |       // 可能是 MMC/SPI/BROM/...|   ||   |-> spl_load_image  // 以emmc启动为例|       |-> spl_mmc_load_image  // common/spl/spl_mmc.c|           |-> spl_mmc_load // 具体可看后面的流程||-> spl_perform_fixups  // vendor hook，用于修改device-tree传递参数|-> spl_board_prepare_for_boot  // vendor hook, 可不实现|-> jump_to_image_no_args   // 跳转到u-boot执行

MMC 加载

SPL 从 MMC 加载 U-Boot 的处理过程。程序编码的时候，针对 MMC 设备添加了对应的加载程序支持，如 spl_mmc.c 中，通过使用宏: SPL_LOAD_IMAGE_METHOD(“MMC1”, 0, BOOT_DEVICE_MMC1, spl_mmc_load_image);
将 spl_mmc_load_image 函数添加到 .u_boot_list_2_spl_image_loader_* 段。

在 SPL 初始化过程中，通过 boot_from_devices(spl_boot_list) 函数调用，检查当前项目所支持的 SPL 读取的存储介质类型，然后依次检查是否存在对应的程序加载器。

board_init_r()    // common/spl/spl.c
|-> boot_from_devices(spl_boot_list)|-> spl_ll_find_loader()  // 根据boot device找到spl_load_image指针// 这里可能是各种介质的 load image 函数// SPL_LOAD_IMAGE_METHOD() 定义的 Loader// 可能是 MMC/SPI/BROM/...

找到 SPL MMC Loader 之后，从项目配置的指定 Sector 读取数据。

CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR


boot_from_devices(spl_boot_list); // common/spl/spl.c
|-> spl_ll_find_loader()  // 根据boot device找到spl_load_image指针
|   // 此处通过遍历固件的 .u_boot_list_2_spl_image_loader_* 段
|   // 找到当前支持的存储介质，然后逐个尝试
|
|-> spl_load_image(loader);|-> loader->load_image(spl_image, &bootdev);spl_mmc_load_image();  // common/spl/spl_mmc.c|-> spl_mmc_load();|+-------------+|
spl_mmc_load();
|-> spl_mmc_find_device(&mmc, bootdev->boot_device);
|   |-> mmc_initialize
|       |-> mmc_probe
|           |-> uclass_get(UCLASS_MMC, &uc)
|           |-> device_probe(dev)
|               |-> uclass_resolve_seq(dev)
|               |-> pinctrl_select_state(dev, "default")
|               |   |-> pinctrl_select_state_full(dev, "default")
|               |   |   |-> state = dev_read_stringlist_search(dev,
|               |   |   |                       "pinctrl-names", "default");
|               |   |   |-> dev_read_prop(dev, propname, &size)
|               |   |   |   // snprintf(propname, sizeof(propname),
|               |   |   |   //              "pinctrl-%d", state)
|               |   |   |
|               |   |   |-> pinctrl_config_one(config)
|               |   |       |-> ops = pinctrl_get_ops(pctldev)
|               |   |       |-> ops->set_state(pctldev, config)
|               |   |
|               |   |-> pinctrl_select_state_simple(dev)
|               |       |-> uclass_get_device_by_seq(UCLASS_PINCTRL, 0, &pctldev)
|               |       |-> ops=pinctrl_get_ops(pctldev)
|               |       |   // #define pinctrl_get_ops(dev)
|               |       |   //         ((struct pinctrl_ops *)(dev)->driver->ops)
|               |       |
|               |       |-> ops->set_state_simple(pctldev, dev)
|               |
|               |-> power_domain_on(&powerdomain)
|               |-> uclass_pre_probe_device(dev)
|               |-> clk_set_defaults(dev)
|               |   |-> clk_set_default_parents(dev)
|               |   |-> clk_set_default_rates(dev)
|               |
|               |-> drv->probe(dev)
|               |-> uclass_post_probe_device(dev)
|
|-> mmc_init
|-> boot_mode=spl_boot_mode(bootdev->boot_device)
|-> mmc_load_image_raw_sector|-> header=spl_get_load_buffer(-sizeof(*header), bd->blksz)|   // header位于load_addr偏移-head_size处||-> blk_dread(bd, sector, 1, header)|   // 读取一个sector的u-boot image header||-> mmc_load_legacy(spl_image, mmc, sector, header)|   |-> spl_parse_image_header(spl_image, header)|   // 解析u-boot image header信息，得到u-boot的addr和size信息||-> blk_dread(bd, sector, cnt, load_addr)// 读取完整的u-boot image，包括header，注意load_addr是向前偏移过的地址