uboot的基本概念和啟動流程分析

1 基本概念

1.1 uboot 是什么？

當我們厭倦了裸機程序，而想要采用操作系統的時候，uboot就是不得不引入的一段程序。所以，uboot就是一段引導程序，在加載系統內核之前，完成硬件初始化，內存映射，為后續內核的引導提供一個良好的環境。uboot是bootloader的一種，全稱為universal boot loader。

1.2 存儲器

在了解 Uboot 之前，我們先來了解一下代碼的載體，看看代碼到底存儲在什么地方！

1. norflash/nandflash、SRAM 和 SDRAM 作為存儲器有何異同？

1. norflash - 是非易失性存儲器（也就是掉電保存）

NOR flash 帶有 SRAM 接口，有足夠的的地址引腳進行尋址，可以很容易地讀取其內部的每一個字節。

注意是Read！因為 flash 不是任意寫入，而是遵循disable write protect -> erase -> write。這是 flash 的特性決定的，其電路只能從1->0，而不能0->1翻轉。

擦除過程就是將 flash 中的某一個扇區恢復為0xFFFFFFFF，然后再寫入數據。另外，代碼指令可以直接在 norflash 上運行。

（重要?。?！上電后可以讀取 norflash 中的數據但是不可以進行寫操作） 2. nandflash - 是非易失性存儲器（也就是掉電保存）

它也是非易失閃存（掉電不丟失）的一種，但是它雖然有數據總線，但是沒有地址總線，所以 cpu 不能直接從 nandflash 中取指運行，由于它價格便宜，所以常常用來存儲大量數據，和我們常說的硬盤類似。

3. SRAM - 靜態隨機訪問存儲器 - Static Random Access Memory

static是指只要不掉電，存儲在 SRAM 中的數據就不會丟失。這一點與 DRAM 不同，DRAM 需要進行周期性刷新操作。然而，我們不應將SRAM 和只讀存儲器（ROM）、Flash Memory 相混淆，因為 SRAM 是一種易失性存儲器，它只有在電源保持連續供應的情況下才能夠保持數據。
Random Access指的是存儲器的內容可以任意順序進行訪問，而不管前一次訪問的是哪一個位置。（重要?。?！上電后就可以讀寫 SRAM 中的數據，而無需初始化操作）

4. SDRAM - 同步動態隨機存取存儲器 - Synchronous Dynamic Random Access Memory

需要不斷的刷新，才能保存數據。而且是行列地址復用，許多都有頁模式。

（重要?。?！需要對 DDR 控制器進行初始化 <配置寄存器>，才能去讀寫 SDRAM 中的數據）

5. 存儲器在 ARM 處理器上的作用。

（1）NOR Flash - 程序存儲器

作為 ARM 處理器的程序存儲器。因為我們必須將程序保存在一個掉電后還能保存數據的地方。上電后，NOR Flash 就相當于一個隨機讀取的只讀存儲器。

那么，既然 NOR Flash 可以運行程序，我們為什么不直接在其上運行程序呢？

一般情況下，我們編譯的程序中，.text段，.rodata段都是只讀的，這沒有問題。但是，.data段（數據段）和.bss（未初始化的全局變量和靜態變量）在程序的運行過程中變量的值是需要改變的（改變一個變量的值，需要改變對應物理地址上
存儲的內容），很可惜，NOR Flash 只能直接讀取，而無法進行寫操作。

那么，為了解決這個問題，就需要 SRAM 了。

（2）SRAM - 提供運行環境

其重要特性就是：容量小，512KB；運行程序速度快；價格貴。

可以作為程序運行時的堆?？臻g。把 ARM 處理器的堆棧指針 sp 設置在 SRAM 中，為程序提供運行環境。

SRAM 作為運行程序的場所是可以的，但是由于其昂貴的價格，極小的容量，而現在程序一般都非常龐大，所以滿足不了我們的需求。正因為此，SDRAM 應運而生。

（3）SDRAM - 運行程序

它的重要特性是容量大：512M；程序運行速度快；價格便宜。

但是其掉電易失數據，上電后必須初始化 DDR 控制器，否則無法進行數據的讀寫。所以在運行系統內核之前必須對其進行初始化，這就是在 NOR Flash 和 SRAM 上搭建的程序的作用。

那它主要都完成什么工作呢？

1.完成對處理器時鐘的初始化

2. DDR的初始化

3. 給 gd_t *gd_ptr 賦值(用于存儲uboot鏡像的長度，重定位地址，

重定位偏移量等信息)

在 uboot 搬運到 DDR 中運行前進行最小系統的初始化，之后就將 uboot 搬運到 DDR 中運行。那么，此時 NOR Flash 和 SRAM 的任務就完成了（也就是沒有用了）。

總結：

從 norflash 啟動可以省事多了，不僅如此，我們自己編寫的裸機程序需要調試，一般也是直接燒寫到 norflash 中進行的，因為只要我們將編譯好的可執行文件放到 norflash 的開始，開發板上電以后就會從 norflash 的第一條指令開始取指執行，我們后面寫裸機程序的調試就是用這種方式進行的。 從 norflash 啟動雖然從開發的角度會很方便（其實也方便不了多少），但是從產品的角度卻增加了它的成本，畢竟 norflash 還是相對較貴的，我們明明只要一塊 nandflash 就足夠啟動整個開發板了，就沒必要在產品中添加一塊 norflash 了，只要代碼改改就能省下不少成本，何樂不為。 而且 nandflash 對產品是必不可少的，因為后面還要存放內核和文件系統，起碼需要幾十兆的空間，用 norflash 來存儲也不現實。

也許你會想，能不能只用 norflash，不用 nandflash 和 SDRAM 行不行呢，畢竟 norflash 即可以存儲，也可以運行程序的啊，從理論來說是可以的，但是了解一下他們的市場價格、運行速度和工作原理，應該就會知道答案了。

2 uboot 鏈接文件

前面我們已經了解了嵌入式設備的存儲介質，以及它們的用途。但是，對于編譯后的代碼如何在內存上分配，處理器是不知道，這需要我們人為地指定。這時候，后綴為 lds 的鏈接文件出現了，它規定了編譯后的代碼各個段是如何分配的。理解了它，對于我們對 u-boot 也是大有幫助的。下面我們直接看代碼內容，如果需要了解語法，請參考 2.3 鏈接文件語法。

2.1 u-boot.lds 文件分析

文件位置：u-boot/board/mini2440/u-boot.lds。

OUTPUT_FORMAT("elf32-littlearm","elf32-littlearm","elf32-littlearm")/*指定輸出可執行文件是elf格式,32位ARM指令,小端*/
OUTPUT_ARCH(arm)                                                    /*指定輸出可執行文件的platform為ARM*/
ENTRY(_start)                                                       /*指定輸出可執行文件的起始地址為_start*/
SECTIONS
{
    /* 指定可執行文件（image）的全局入口點，通常這個地址都放在ROM(flash)0x0位置。*/
    /* 必須使編譯器知道這個地址，通常都是修改此處來完成 */
    . = 0x00000000;                                 /* 從0x0位置開始 */

   . = ALIGN(4);                                   /* 代碼以4字節對齊 */
    .text :
    {
      cpu/arm920t/start.o (.text)                 /* 從start.S文件中的代碼開始 */
        cpu/arm920t/s3c24x0/nand_read.o (.text)     /* 關于nand讀取的代碼 */
        *(.text)                                    /* 其它代碼部分*/
    }

    . = ALIGN(4);
    .rodata : { *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.rodata*))) } /*指定只讀數據段*/

    . = ALIGN(4);
    .data : { *(.data) }                            /* 指定讀/寫數據段，RW段 */

    . = ALIGN(4);
    .got : { *(.got) }                              /*指定got段, got段是uboot自定義的一個段, 非標準段*/

    . = .;
    __u_boot_cmd_start = .;                         /*把__u_boot_cmd_start賦值為當前位置, 即起始位置*/
    .u_boot_cmd : { *(.u_boot_cmd) }                /*指定u_boot_cmd段, uboot把所有的uboot命令放在該段.*/
    __u_boot_cmd_end = .;                           /*把__u_boot_cmd_end賦值為當前位置,即結束位置*/

    . = ALIGN(4);
    __bss_start = .;                                /*把__bss_start賦值為當前位置,即bss段的開始位置*/
    .bss (NOLOAD) : { *(.bss) . = ALIGN(4); }       /*指定bss段,告訴加載器不要加載這個段*/
    __bss_end = .;                                  /*把_end賦值為當前位置,即bss段的結束位置*/
}

通過上面的分析可以看出

由于在鏈接腳本中規定了文件 start.o(對應于 start.S) 作為整個 uboot 的起始點，因此啟動 uboot 時會執行首先執行 start.S。

一般來說，內存空間可分為代碼段、數據段、全局變量段、未初始化變量區、棧區、堆區等. 其中，棧區由指針 SP 決定，堆區實質上是由 C 代碼實現的，其它段則由編譯器決定. 從上面的分析可以看出，從 0x00000000 地址開始，編譯器首先將代碼段放在最開始的位置，然后是數據段，然后是 bss 段 (未初始化變量區).

2.2 System.map 文件

我們來看一下System.map這個文件：

33f80000 T _start
33f80020 t _undefined_instruction
......(中間省略)
33f80fd8 T start_armboot

如何設置從 0x33f80000 開始呢?~ 這是鏈接的時候指定的。在 u-boot 根目錄下面的 config.mk 中有下面一句

LDFLAGS += -Bstatic -T $(LDSCRIPT) -Ttext $(TEXT_BASE) $(PLATFORM_LDFLAGS)

其中的 - Ttext $(TEXT_BASE), 這句指明了代碼段的起始地址。而 TEXT_BASE 在 board/mini2440/config.mk 中定義 TEXT_BASE = 0x33F80000

為什么是 0x33F80000 呢?~

我們先來看一下 S3C2440 的內存分布圖：

如上圖所示，如果選擇 NAND flash 為引導 ROM 時，為了支持 NAND Flash 的 BootLoader，S3C2440A 配備了一個內置的 SRAM 緩沖器，叫做 “Steppingstone”， 具體如下圖所示。引導啟動時，NAND Flash 存儲器的開始 4K 字節將被自動加載到 Steppingstone 中并且執行自動加載到 Steppingstone 的引導代碼。

所以說，雖然我們在鏈接文件 u-boot.lds 中指定了起始地址是 0x00000000，但是在 config.mk 的編譯構造文件中還指定了起始地址是 0x33f80000。

因為我們的 u-boot 代碼在上面的 4k 代碼執行完成后，還是要跳轉到 0x33f80000 處執行的。所以，鏈接文件中的默認 0x00000000 起始地址不需要起作用。

查看 S3C2440 的 datasheet，如下圖所示，

可以看出 64M 空間對應的地址為 0x30000000~0x33FFFFFF。TEXT_BASE=0x33F80000 即為程序加載起始地址，可以使用的空間大小即為 0x33F80000 到 0x33FFFFFF 共 512K ，如果你 u-boot 包含的功能太多，覺得不夠用，你可以把 0x33F80000 調小一點， 即和往低地址移一些，移的過程中注意內存頁對齊就行了，一般是 4KB。

2.3 鏈接文件語法

下面是一些比較難懂的 lds 文件的語法，先記錄如下。對于常用語法可以自行查閱，網上資料還是蠻多的。

2.3.1 .got 語法

在了解這個語法之前，我們先來了解一些其他概念：

加載時重定位

基本思路是：在鏈接時，對所有絕對地址的引用不作重定位，而把這一步推遲到裝載時再完成。一旦模塊裝載地址確定，即目標地址確定，那么系統就對程序中所有的絕對地址引用進行重定位。

設函數 foobar 相對于代碼段的起始地址是 0x100, 當模塊被裝載到 0x10000000 時，我們假設代碼段位于模塊的最開始，即代碼段的裝載地址也是 0x10000000, 那么我們就可以確定 foobar 的地址為 0x10000100。這時候，系統遍歷模塊中的重定位表，把所有對 foobar 的地址引用都重定位至 0x10000100。

地址無關代碼（position-independent-code，PIC），又稱為地址無關可執行文件（position-independent-executable，PIE）

加載時重定位解決了動態模塊中有絕對地址引用的問題，但是又帶來了指令部分無法在多個進程間共享的問題。

具體想法就是把程序模塊中共享的指令部分在加載時不需要因為加載地址的改變而改變。把指令中那些需要被修改的部分分離出來，跟數據部分放在一起，這樣指令部分就可以保持不變，而數據部分可以在每個進程中擁有一個副本。這種方案就是目前的地址無關代碼（PIC）技術。

具體方法：先分析模塊中各種類型的地址引用方式，把共享對象模塊中地址引用按照是否跨模塊分為兩類：模塊內部引用和模塊外部引用。按照不同的引用方式又可以分為指令引用和數據訪問。

1. 第一種是模塊內部的函數調用、跳轉等。
 2. 第二種是模塊內部的數據訪問，比如模塊中定義的全局變量、靜態變量。
 3. 第三種是模塊外部的函數調用、跳轉等。
 4. 第四種是模塊外部的數據訪問，比如其它模塊中定義的全局變量。

全局偏移表（GOT）

對于類型三，我們需要用到代碼地址無關（PIC）技術，基本的思想就是把跟地址相關部分放到數據段里面。ELF 的做法是在數據段里建立一個指向這些變量的指針數組，稱為全局偏移表（GOT），當代碼需要引用該全局變量時，可以通過 GOT 中相對應的項間接引用。由于 GOT 本身是放在數據段的，所以它可以在模塊裝載時被修改，并且每個進程都可以有獨立的副本，相互不受影響。

對于跨模塊的數據訪問也是如此，不做細致分析了。

3 uboot 啟動流程第 1 階段

主要脈絡：部分硬件初始化 -> 加載完整的 uboot 到 RAM -> 跳轉到第 2 階段入口開始執行

第 1 階段主要用到的文件是：

start.S 文件，位于u-boot/cpu/arm920t/start.S

lowlevel_init.S 文件，位于u-boot/board/smdk2410/lowlevel_init.S

3.1 start.S 文件分析

文件位置：

1. 啟動 -_start

查看下面的代碼：

_start:                                 # 異常處理向量表
b start_code
ldr pc, _undefined_instruction          # 未定義指令異常：0x00000004
ldr pc, _software_interrupt             # 軟中斷異常:0x00000008
ldr pc, _prefetch_abort                 # 預取異常：0x0000000C
ldr pc, _data_abort                     # 數據異常:0x00000010
ldr pc, _not_used                       # 未使用：0x00000014
ldr pc, _irq                            # 外部中斷請求IRQ:0x00000018
ldr pc, _fiq                            # 快束中斷請求FIQ:0x0000001C

從上面的內容可以看出，除第 1 行代碼之外，其余代碼都是跳轉到特定位置去執行中斷服務子程序。

正常情況下，程序的執行流程是不會走到中斷處理流程中去的，而是直接跳轉到 reset 處開始執行。那我們接下來就看 reset 處的代碼都干了什么。

2. reset - 設置超級管理模式

設置 CPU 為 SVC32 模式，即超級管理權限模式

start_code:
    mrs r0,cpsr             # 將程序狀態寄存器讀取到通用寄存器R0
    bic r0,r0,#0x1f         # 清除當前的工作模式
    orr r0,r0,#0xd3         # 設置超級管理員權限
    msr cpsr,r0             # 將結果寫回到CPSR寄存器

cpsr 是 ARM 體系結構中的程序狀態寄存器，其結構如下：

M[4:0]	CPU 模式	可訪問寄存器	說明
0b10000	user	pc,R14~R0,CPSR	正常 ARM 程序執行狀態
0b10001	FIQ	PC,R14_FIQ-R8_FIQ,R7~R0,CPSR,SPSR_FIQ	為支持數據傳輸或通道處理設計
0b10010	IRQ	PC,R14_IRQ-R13_IRQ,R12~R0,CPSR,SPSR_IRQ	用于一般用途的中斷處理
0b10011	SUPERVISOR	PC,R14_SVC-R13_SVC,R12~R0,CPSR,SPSR_SVC	操作系統保護模式
0b10111	ABORT	PC,R14_ABT-R13_ABT,R12~R0,CPSR,SPSR_ABT	數據或指令預取中止后進入
0b11011	UNDEFINED	PC,R14_UND-R8_UND,R12~R0,CPSR,SPSR_UND	執行未定義指令時進入
0b11111	SYSTEM	PC,R14-R0,CPSR(ARM V4 以及更高版本）	操作系統的特權用戶模式

I、F、T 三位如果寫 1 即禁用，所以 reset 后面的 4 句操作的結果為設置 CPU 為 SUPERVISOR 模式且禁用中斷。那為什么選擇這個模式呢？

首先，可以排除的就是 ABORT 和 UNDEFINED 模式，看上去就不像正常模式。

其次，對于快速中斷 fiq 和中斷 irq 來說，此處 uboot 初始化的時候，也還沒啥中斷要處理和能夠處理，而且即使是注冊了終端服務程序后，
能夠處理中斷，那么這兩種模式，也是自動切換過去的，所以，此處也不應該設置為其中任何一種模式。

于 usr 模式，由于此模式無法直接訪問很多的硬件資源，而 uboot 初始化，就必須要去訪問這類資源，所以此處可以排除，不能設置為用戶 usr 模式。

而 svc 模式本身就屬于特權模式，本身就可以訪問那些受控資源，而且，比 sys 模式還多了些自己模式下的影子寄存器，所以，相對 sys 模式來說，
可以訪問資源的能力相同，但是擁有更多的硬件資源。

3. 關閉看門狗

ldr     r0, =pWTCON         # 取得看門狗寄存器的地址
mov     r1, #0x0            # 將R1寄存器清0
str     r1, [r0]            # 將看門狗寄存器清0，即將看門狗禁止，包括定時器定時，溢出中斷及溢出復位等

4. 關中斷

mov r1, #0xffffffff         # 設R1寄存器為0xFFFF FFFF
ldr r0, =INTMSK             # 讀取中斷屏蔽寄存器的地址
str r1, [r0]                # 將中斷屏蔽寄存器中的位全設1,屏蔽所有中斷

ldr r1, =INTSUBMSK_val      # 設R1寄存器為0xFFFF
ldr r0, =INTSUBMSK          # 讀取輔助中斷屏蔽寄存器的地址
str r1, [r0]                # 將輔助中斷屏蔽寄中的11個中斷信號屏蔽掉，本人覺得INTSUBMS_val應設成7ff

5. 設置時鐘

6. 關閉 MMU，設置 ARM 時序

#ifndef CONFIG_SKIP_LOWLEVEL_INIT
cpu_init_crit:
    // 使I/D cache失效：協處理寄存器操作，將r0中的數據寫入到協處理器p15的c7中，c7對應cp15的cache控制寄存器
    mov r0, #0
    mcr p15, 0, r0, c7, c7, 0   /* flush v3/v4 cache */
    mcr p15, 0, r0, c8, c7, 0   /* flush v4 TLB */ 使TLB操作寄存器失效：將r0數據送到cp15的c8、c7中。C8對應TLB操作寄存器

    /*
     * 禁用MMU和緩存
     */
    mrc p15, 0, r0, c1, c0, 0   // 將c1、c0的值寫入到r0中
    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   // 將設置好的r0值寫入到協處理器p15的c1、c0中，關閉MMU

    /*
     * 在重加載之前，我們必須設置RAM的時序，因為內存的時序依賴于板子，
     * 在board目錄下可以發現lowlevel_init.S文件
     */
    mov ip, lr                  // 將lr寄存器內容保存到ip寄存器中，用于子程序調用返回
#if defined(CONFIG_AT91RM9200DK) || defined(CONFIG_AT91RM9200EK) || defined(CONFIG_AT91RM9200DF)
#else
    bl  lowlevel_init           // 跳轉到`lowlevel_init`地址執行
#endif
    mov lr, ip
    mov pc, lr
#endif /* CONFIG_SKIP_LOWLEVEL_INIT */

1. Cache 是什么呢？

Cache 是處理器內部的一個高速緩存單元，為了應對處理器和外部存儲器之間的速度不匹配而設立的。其速度要比內存的讀寫速度快好多，接近處理器的工作速度，一般處理器從內存中讀取數據到 Cache 中，到下次再用到數據時，會先去 cache 中查找，如果 cache 中存在的話，就不會訪問內存了，用以提高系統性能。

2. 系統引導時為什么關閉 Cache？

從上面的解釋中，可以看出，在系統未初始化完成時，代碼還沒有轉移到內存中，也就是說，我們還沒有用到內存，先將 MMU 和 Cache 關閉，以免發生不可預料的錯誤。

3. 怎樣使 Cache 中的數據無效？

見上面的代碼。

3.2 lowlevel_init.S 文件分析

3.2.1 RAM 初始化

這一步主要完成 RAM 的初始化，也就是通過寫控制 RAM 的寄存器，對寄存器的存取方式進行控制。主要代碼位于文件lowlevel_init.S中。

lowlevel_init.S文件內容如下：

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                    // 讀取下面標號為SMRDATA處的地址到R0中
    ldr r1, _TEXT_BASE                  // 程序的加載地址 TEXT_BASE = 0x33F80000 到 R1中
    sub r0, r0, r1                      // 計算SMRDATA的相對地址保存到R0中，
                                        /* SMRDATA為虛擬地址,而TEXT_BASE為虛擬地址的起始地址
                                         * TEXT_BASE為0x33F8 0000,SMRDATA為0x33F8 06C8
                                         * 而現在程序運行在起始地址為0x0000 0000的地方
                                         * 所以需要計算以0x0000 0000為標準的相對地址 */
    ldr r1, =BWSCON                     // 取得帶寬與等待狀態控制寄存器地址到R1中，也就是控制內存的寄存器的首地址
    add r2, r0, #13*4                   // R2保存要操作的寄存器的個數，在這兒是13
0:
    ldr     r3, [r0], #4                // 數據處理后R0自加4，[R0]->R3，R0+4->R0
    str     r3, [r1], #4                // 將這些數據寫入到控制內存的寄存器中。
    cmp     r2, r0                      // 循環從Flash中讀取13個Word大小的值到內存中
    bne     0b

    mov pc, lr                          // 返回函數lowlevel_init()的調用地方

    .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))
    //設置REFRESH,在S3C2440中11～17位是保留的，也即(Tchr<<16)無意義
    .word ((REFEN<<23)+(TREFMD<<22)+(Trp<<20)+(Trc<<18)+(Tchr<<16)+REFCNT)
    .word 0x32      // 設置BANKSIZE,對于容量可以設置大寫，多出來的空內存會被自動檢測出來
    .word 0x30      // 設置MRSRB6
    .word 0x30      // 設置MRSRB7

3.2.2 Uboot 代碼加載

#ifndef CONFIG_SKIP_RELOCATE_UBOOT
    adr r0, _start          /* r0保存當前程序的位置 */
relocate:                   /* 將uboot代碼重定位到RAM中 */
    teq r0, #0              /* 測試是否從地址0開始運行 */
    bleq    may_resume      /* yes -> do low-level setup */

    adr r0, _start          /* 上面的代碼有可能會破會r0中的值 */
    ldr r1, _TEXT_BASE      /* 測試從Flash還是RAM中運行程序，它們的地址是不一樣的 */
    cmp r0, r1              /* 在debug期間不需要重定位，直接在Flash中運行代碼 */
    beq     done_relocate

    ldr r2, _armboot_start
    ldr r3, _bss_start
    sub r2, r3, r2          /* 根據前面分析的uboot.lds文件可知，r3-r2就是uboot代碼的大小，將其存入寄存器r2中 */
    add r2, r0, r2          /* r0是程序的起始地址，加上uboot代碼的大小就是uboot代碼的結束地址 */

copy_loop:
    ldmia   r0!, {r3-r10}   /* 從源地址[r0]處開始拷貝 */
    stmia   r1!, {r3-r10}   /* 拷貝到目標地址[r1]處 */
    cmp r0, r2              /* 直到源代碼結束地址[r2] */
    ble copy_loop

3.2.3 建立堆棧

設置堆棧，其中，_TEXT_BASE=0x33F80000，而CFG_MALLOC_LEN，CFG_GBL_DATA_SIZE，CONFIG_STACKSIZE_IRQ，CONFIG_STACKSIZE_FIQ在文件uboot/include/configs/mini2440.h文件中定義。

/* 建立堆棧 */
stack_setup:
    ldr r0, _TEXT_BASE                                          /* upper 128 KiB: relocated uboot   */
    sub r0, r0, #CFG_MALLOC_LEN                                 /* malloc area */
    sub r0, r0, #CFG_GBL_DATA_SIZE                              /* bdinfo */
#ifdef CONFIG_USE_IRQ
    sub r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)
#endif
    sub sp, r0, #12                                         /* leave 3 words for abort-stack    */

3.2.4 清除 bss 段

clear_bss:
    ldr r0, _bss_start                                          /* find start of bss segment        */
    ldr r1, _bss_end                                            /* stop here                        */
    mov     r2, #0x00000000                                     /* clear                            */

clbss_l:str r2, [r0]                                            /* clear loop...                    */
    add r0, r0, #4
    cmp r0, r1
    ble clbss_l

3.2.5 跳轉到 uboot 第 2 階段

ldr pc, _start_armboot

_start_armboot: .word start_armboot

初始化外設完成之后，程序跳轉到 u-boot 第 2 階段的入口函數start_armboot。ldr pc，_start_armboot為絕對跳轉命令，pc 值等于_start_armboot的連接地址，程序跳到 SDRAM 中執行。在此之前程序都是在 flash 中運行的，絕對跳轉必須在初始 SDRAM，執行代碼重定位之后才能進行。

4 uboot 啟動流程第 2 階段

第 2 階段，uboot 完成進一步的硬件初始化，并設置了 uboot 下的命令行、環境變量、并跳轉到內核中。其主要用到的文件是：

board.c 文件，位于u-boot/lib_arm/board.c

main.c 文件，位于u-boot/common/main.c

4.1 初始化

void start_armboot (void)
{
    init_fnc_t **init_fnc_ptr;
    char *s;
#ifndef CFG_NO_FLASH
    ulong size;
#endif
#if defined(CONFIG_VFD) || defined(CONFIG_LCD)
    unsigned long addr;
#endif

    /* 在上面的代碼中gd的值綁定到寄存器r8中了 */
    gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t));
    /* 為GCC >= 3.4以上的編譯進行代碼優化，而插入內存barrier */
    __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));

    monitor_flash_len = _bss_start - _armboot_start;

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

首先，我們先來分析init_fnc_t **init_fnc_ptr;這行代碼。

要分析這行代碼，首先看指針數組init_fnc_t *init_sequence[]

typedef int (init_fnc_t) (void);

init_fnc_t *init_sequence[] = {
    cpu_init,               /* 與CPU相關的初始化 */
    board_init,             /* 與板子初始化相關的初始化 */
    interrupt_init,         /* 中斷初始化 */
    env_init,               /* 初始化環境變量 */
    init_baudrate,          /* 初始化波特率設置 */
    serial_init,            /* serial通信相關初始化 */
    console_init_f,         /* console初始化的第一部分 */
    display_banner,         /* say that we are here */
    // ...根據配置，還有一些其它的初始化
    dram_init,              /* 配置可用的RAM塊 */
    display_dram_config,
    NULL,
};

根據這兒的分析，我們就可以知道init_fnc_ptr就是一個函數指針。在后面的 for 循環中，將函數指針數組的首地址init_sequence賦值給init_fnc_ptr，然后循環，對所有的硬件進行初始化。

而對于代碼gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t));確實有些抽象。而要分析它，必須看一下下面這個宏定義：

DECLARE_GLOBAL_DATA_PTR;        //在board.c最上面

而它的定義如下：

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

這個聲明，告訴編譯器使用寄存器 r8 來存儲 gd_t 類型的指針 gd，即這個定義聲明了一個指針，并且指明了它的存儲位置。也就是說，我們聲明了一個寄存器變量，它的初始值為_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t)，也就是0x33F80000-(0x20000+2048*1024)-0x24。也就是說，gd 指向了一段可用的內存區域，而這段內存區域相當于 u-boot 的全局變量。

那指針 gd 指向的數據結構到底是什么呢？為什么要設置這個數據結構呢？那么接下來讓我們看一下這個數據結構吧。

typedef struct  global_data {
    bd_t            *bd;
    unsigned long   flags;
    unsigned long   baudrate;
    unsigned long   have_console;   /* serial_init() 函數被調用 */
    unsigned long   reloc_off;      /* Relocation Offset */
    unsigned long   env_addr;       /* Address  of Environment struct */
    unsigned long   env_valid;      /* Checksum of Environment valid? */
    unsigned long   fb_base;        /* base address of frame buffer */
#ifdef CONFIG_VFD
    unsigned char   vfd_type;       /* display type */
#endif
    void            **jt;           /* jump table */
} gd_t;

這個數據結構是系統初始化的最小全局變量值，主要在 boot 引導的早期使用，直到我們設置好內存控制器并能夠訪問 RAM。注意，保證CFG_GBL_DATA_SIZE大于sizeof（gd_t）。

對于其中的變量，我們進行重點分析。bd_t *bd;這句話中，結構體bd_t的內容如下：

typedef struct bd_info {
    int             bi_baudrate;    /* 串口控制臺波特率 */
    unsigned long   bi_ip_addr;     /* IP 地址 */
    unsigned char   bi_enetaddr[6]; /* Ethernet adress */
    struct environment_s *bi_env;
    ulong           bi_arch_number; /* 該板唯一的ID */
    ulong           bi_boot_params; /* 存放參數的地方 */
    struct                          /* RAM配置 */
    {
        ulong start;
        ulong size;
    }               bi_dram[CONFIG_NR_DRAM_BANKS];
    // ......
} bd_t;

從上面的代碼中，可以看出，在該結構體內，存放著 boot 引導前期，系統初始化的最小集合。要么通過串口打印，要么通過網絡打印進行人機交互。

// ...... 此處，如果有LCD等設備，為其準備內存空間
    /* armboot_start在與板子相關的鏈接腳本文件中定義，初始化動態內存 */
    mem_malloc_init (_armboot_start - CFG_MALLOC_LEN);

    // 其他存儲空間的初始化

    env_relocate ();        /* 初始化環境變量 */

    gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");  /* 得到IP地址 */

    /* 獲取MAC地址 */
    {
        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;
        }
        // ...
    }

    devices_init ();        /* 獲取設備列表 */

    jumptable_init ();

    console_init_r ();      /* 將完全初始化的控制臺作為一個設備 */

    enable_interrupts ();   /* 使能異常中斷 */

    /* 如果有必要，執行網卡的初始化工作 */

    /* main_loop() can return to retry autoboot, if so just run it again. */
    for (;;) {
        main_loop ();
    }

    /* 不可到達 */
}

4.2 加載內核

首先，我們將main_loop函數進行簡化，如下圖所示。這個流程非常簡單明了。

void main_loop (void)
{
    static char lastcommand[CFG_CBSIZE] = { 0, };
    int len;
    int rc = 1;
    int flag;

    char *s;
    int bootdelay;

    s = getenv ("bootdelay");               // 獲取延時時間
    bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;

    s = getenv ("bootcmd");                 // 獲取引導命令

    // 判斷延時時間是否到，到了的話直接執行引導命令；如果在此期間有按鍵按下，則進入For循環
    if (!nobootdelay && bootdelay >= 0 && s && !abortboot (bootdelay)) {
        run_command (s, 0);
    }

    // 主循環，監控命令，并根據命令作出相應的處理
    for (;;) {
        len = readline (CFG_PROMPT);
        flag = 0;                                       /* assume no special flags for now */
        if (len > 0)
            strcpy (lastcommand, console_buffer);
        else if (len == 0)
            flag |= CMD_FLAG_REPEAT;
        // ......其它代碼
        if (len == -1)
            puts ("
");
        else
            rc = run_command (lastcommand, flag);       /* 執行命令 */

        if (rc <= 0) {
            lastcommand[0] = 0;                         /* 非法的或不可重復的命令 */
        }
    }
}

下面我們來看run_command函數的內容，看看到底在執行什么。經簡化可得，這個函數有 2 種流程，一種是按照 hush 表查找命令，另一種就是下面這個，簡單粗暴：

int run_command(const char *cmd, int flag)
{
    if (builtin_run_command(cmd, flag) == -1)
        return 1;
    return 0;
}

那么，我們再來看函數builtin_run_command：

static int builtin_run_command(const char *cmd, int flag)
{
    //合法性校驗
    while (*str) {
        //特殊字符解析
        }
    process_macros (token, finaltoken); //宏展開，即完全解析命令

    //命令執行過程
    if (cmd_process(flag, argc, argv, &repeatable))
        rc = -1;
    return rc ? rc : repeatable;
}

最后，我們再來看一下函數cmd_process:

cmd_process(int flag, int argc, char * const argv[],
                   int *repeatable)
{
    cmd_tbl_t *cmdtp;

    cmdtp = find_cmd(argv[0]); //查找命令
    if (cmdtp == NULL) {
        printf("Unknown command '%s' - try 'help'
", argv[0]);
        return 1;
    }

    if (argc > cmdtp->maxargs)
        rc = CMD_RET_USAGE;

    /* If OK so far, then do the command */
    if (!rc) {
        rc = cmd_call(cmdtp, flag, argc, argv); //真正的執行命令
        *repeatable &= cmdtp->repeatable;
    }
    return rc;
}

至此，uboot 的使命便完成了，將執行的權利交給 linux 內核。

審核編輯：湯梓紅