linux怎么编译vboot,vboot完全解读

上半个月在学习bootloader，突然找到了一个非常好的vboot，vboot只有最基本的内核引导功能(基于s3c2440，从nand flash启动)，对其深入研究后，发现对bootloader有了比较全面的理解，虽然没有像uboot那么多功能，但vboot已经实现了bootloader最核心的功能，其他像什么网络功能、烧写功能等等也只是一些裸机驱动而已。学习bootloader需要有汇编的基础，如果有单片机编程经验的话那更是“如鱼得水”了。

先看vboot的整体架构，下面是vboot包含的所有文件：

很简单是吧，其中核心的文件是head.S、main.c和nand.c，vboot.bin已经是编译出来的二进制文件，用于烧写在nand flash里。先看mem.lds文件，这是一个链接脚本，从那里可以找到程序的入口：

1 SECTIONS {

2 . = 000000;

3 .myhead ALIGN(0): {*(.text.FirstSector)}

4 .text ALIGN(512): { *(.text) }

5 .bss ALIGN(4) : { *(.bss*) *(COMMON) }

6 .data ALIGN(4) : { *(.data*) *(.rodata*) }

7 }

比较简单，程序入口位于text.FirstSector这个段里(因为程序是从nand flash的0地址开始执行的)，它在head.S文件里定义：

1 .section .text.FirstSector

2 .globl first_sector

3

4 first_sector:

5 @ 0x00: Reset

6 b Reset

7

8 @ 0x04: Undefined instruction exception

9 UndefEntryPoint:

10 b UndefEntryPoint

11

12 @ 0x08: Software interrupt exception

13 SWIEntryPoint:

14 b SWIEntryPoint

15

16 @ 0x0c: Prefetch Abort (Instruction Fetch Memory Abort)

17 PrefetchAbortEnteryPoint:

18 b PrefetchAbortEnteryPoint

19

20 @ 0x10: Data Access Memory Abort

21 DataAbortEntryPoint:

22 b DataAbortEntryPoint

23

24 @ 0x14: Not used

25 NotUsedEntryPoint:

26 b NotUsedEntryPoint

27

28 @ 0x18: IRQ(Interrupt Request) exception

29 IRQEntryPoint:

30 b IRQHandle

31

32 @ 0x1c: FIQ(Fast Interrupt Request) exception

33 FIQEntryPoint:

34 b FIQEntryPoint

35

36 @0x20: Fixed address global value. will be replaced by downloader.

37

38 .long ZBOOT_MAGIC

39 .byte OS_TYPE, HAS_NAND_BIOS, (LOGO_POS & 0xFF), ((LOGO_POS >>8) &0xFF)

40 .long OS_START

41 .long OS_LENGTH

42 .long OS_RAM_START

43 .string LINUX_CMD_LINE

第5~34行的作用是安装异常向量表，在这里除了复位，其他异常都没有定义具体的执行代码。

1 .section .text

2 Reset:

3 @ 关闭看门狗

4 mov r1, #0x53000000

5 mov r2, #0x0

6 str r2, [r1]

7

8 @ 关闭中断

9 mov r1, #INT_CTL_BASE

10 mov r2, #0xffffffff

11 str r2, [r1, #oINTMSK]

12 ldr r2, =0x7ff

13 str r2, [r1, #oINTSUBMSK]

14

15 @ 初始化系统时钟

16 mov r1, #CLK_CTL_BASE

17 mvn r2, #0xff000000

18 str r2, [r1, #oLOCKTIME] @设置LOCKTIME寄存器

19

20 mov r1, #CLK_CTL_BASE

21 ldr r2, clkdivn_value

22 str r2, [r1, #oCLKDIVN] @设置分频寄存器

23

24 mrc p15, 0, r1, c1, c0, 0 @ read ctrl register

25 orr r1, r1, #0xc0000000 @ Asynchronous 异步总线模式

26 mcr p15, 0, r1, c1, c0, 0 @ write ctrl register

27

28 mov r1, #CLK_CTL_BASE

29 ldr r2, =S3C2440_UPLL_48MHZ_Fin12MHz

30 str r2, [r1, #oUPLLCON]

31

32 nop

33 nop

34 nop

35 nop

36 nop

37 nop

38 nop

39 nop

40 nop

41

42 ldr sp, DW_STACK_START @ setup stack pointer

43

44 ldr r2, mpll_value_USER @ clock user set 12MHz

45 str r2, [r1, #oMPLLCON]

46 bl memsetup

47

48 @ set GPIO for UART

49 mov r1, #GPIO_CTL_BASE

50 add r1, r1, #oGPIO_H

51 ldr r2, gpio_con_uart

52 str r2, [r1, #oGPIO_CON]

53 ldr r2, gpio_up_uart

54 str r2, [r1, #oGPIO_UP]

55 bl InitUART

56

57

58 @ get read to call C functions

59 mov fp, #0 @ no previous frame, so fp=0

60 mov a2, #0 @ set argv to NULL

61

62 bl Main

63

64 1: b 1b @

第4~6行，关闭看门狗，以免系统不断复位；第9~13行，关闭中断；第16~18行，设置系统时钟稳定(锁定)时间；第20~22行，设置时钟分频比为1:4:8(FCLK:HCLK:PCLK)；第24~26行，设置为异步总线模式(因为FCLK已经不等于HCLK)；第28~30,行，设置UPLL为48MHZ，用于USB通信；第42行，设置栈指针，为下面调用c程序做准备；第44~45行，设置FCLK为400MHZ，那么HCLK=100MHZ，PCLK=50MHZ；第46行，跳到内存初始化程序：

1 memsetup:

2 @ initialise the static memory

3

4 @ set memory control registers

5 mov r1, #MEM_CTL_BASE

6 adrl r2, mem_cfg_val

7 add r3, r1, #52 @13*4

8 1: ldr r4, [r2], #4

9 str r4, [r1], #4

10 cmp r1, r3

11 bne 1b

12 mov pc, lr

2440总共有13个设置内存的寄存器，因此第7行的立即数是52(13*4)；第8~11行，通过循环设置13个寄存器的值。返回到memsetup下面的代码：

1 @ set GPIO for UART

2 mov r1, #GPIO_CTL_BASE

3 add r1, r1, #oGPIO_H

4 ldr r2, gpio_con_uart

5 str r2, [r1, #oGPIO_CON]

6 ldr r2, gpio_up_uart

7 str r2, [r1, #oGPIO_UP]

8 bl InitUART

9

10

11 @ get read to call C functions

12 mov fp, #0 @ no previous frame, so fp=0

13 mov a2, #0 @ set argv to NULL

14

15 bl Main

16

17 1: b 1b @

第2~8行，用于初始化串口(115200bps，8N1)；第12~13行，设置两个arm寄存器；第15行，跳到Main函数执行。在main.c文件里：

1 void Main(void)

2 {

3 MMU_EnableICache();

4 MMU_EnableDCache();

5

6 Port_Init();

7 NandInit();

8

9 if (g_page_type == PAGE_UNKNOWN) {

10 Uart_SendString("\r\nunsupport NAND\r\n");

11 for(;;);

12 }

13

14 GetParameters();

15

16 Uart_SendString("loading Image of Linux from Nand Flash...\n\r");

17 ReadImageFromNand();

18 }

第3~4行，使能Dcache和Icache：

static inline void MMU_EnableICache(void)

{

asm (

"mrc p15,0,r0,c1,c0,0\n"

"orr r0,r0,#(1<<12)\n"

"mcr p15,0,r0,c1,c0,0\n"

);

}

static inline void MMU_EnableDCache(void)

{

asm (

"mrc p15,0,r0,c1,c0,0\n"

"orr r0,r0,#(1<<2)\n"

"mcr p15,0,r0,c1,c0,0\n"

);

}

第6行，初始化一些IO口(没用到)；第7行，初始化nand flash控制器，在nand.c文件里定义：

void NandInit(void)

{

NFCONF = (TACLS << 12) | (TWRPH0 << 8) | (TWRPH1 << 4) | (0 << 0);

NFCONT =

(0 << 13) | (0 << 12) | (0 << 10) | (0 << 9) | (0 << 8) | (0 << 6) |

(0 << 5) | (1 << 4) | (1 << 1) | (1 << 0);

NFSTAT = 0;

NandReset();

NandCheckId();

}

设置具体nand flash芯片的时序参数、页的大小和位宽等，初始化之后，就可以读写nand flash了。回到Main函数的第14行调用的GetParameters()函数的定义：

static inline void GetParameters(void)

{

U32 Buf[2048];

g_os_type = OS_LINUX;

//内核在flash中的起始地址

g_os_start = 0x50000;

//内核映像的大小

g_os_length = 0x300000;

//内核被拷贝到内存的起始地址

g_os_ram_start = 0x30008000;

// vivi LINUX CMD LINE

//从flash的参数分区中读命令行参数

NandReadOneSector((U8 *)Buf, 0x40000);

if (Buf[0] == 0x49564956 && Buf[1] == 0x4C444D43) {

memcpy(g_linux_cmd_line, (char *)&(Buf[2]), sizeof g_linux_cmd_line);

}

}

设置了内核映像在nand flash的起始地址和大小，还有设置内核映像被拷贝到ram的起始地址，命令行参数是通过BIOS(nor flash里的supervivi)写到nand flash的0x40000地址处，通过NandReadOneSector()把它读出来，其中Buf[0]、Buf[1]这两个值是“暗藏值”，是对应于具体的BIOS的，是由BIOS写进去的，位于命令行参数的第一和第二个字，因为BIOS的代码不不开源的，无法修改，所以移植vboot的时候只要是用这个BIOS来烧写vboot就不用修改两个值(不用太纠结，我曾纠结了很久)。从memcpy()函数也可以知道，Buf[0]和Buf[1]这两个值是用来识别具体的BIOS的，没用于命令行参数。现在看NandReadOneSector()函数：

1 int NandReadOneSector(U8 * buffer, U32 addr)

2 {

3 int ret;

4

5 switch(g_page_type) {

6 case PAGE512:

7 ret = NandReadOneSectorP512(buffer, addr);

8 break;

9 case PAGE2048:

10 ret = NandReadOneSectorP2048(buffer, addr);

11 break;

12 default:

13 for(;;);

14 }

15 return ret;

16 }

因为我板子(GT2440)上的nand flash是64M的，页的大小为512字节，所以看第7行的调用：

static inline int NandReadOneSectorP512(U8 * buffer, U32 addr)

{

U32 sector;

sector = addr >> 9;

NandReset();

#if 0

NF_RSTECC();

NF_MECC_UnLock();

#endif

NF_nFCE_L();

NF_CLEAR_RB();

NF_CMD(0x00);

NF_ADDR(0x00);

NF_ADDR(sector & 0xff);

NF_ADDR((sector >> 8) & 0xff);

NF_ADDR((sector >> 16) & 0xff);

delay();

NF_DETECT_RB();

ReadPage512(buffer, &NFDATA);

#if 0

NF_MECC_Lock();

#endif

NF_nFCE_H();

return 1;

}

该函数里前面那些是设置读操作，设置读起始地址，核心是调用ReadPage512()函数，它由汇编实现，在head.S里：

1 .globl ReadPage512

2

3 ReadPage512:

4 stmfd sp!, {r2-r7} @ 将r2~r7寄存器的值压栈

5 mov r2, #0x200 @ 512个字节

6

7 1:

8 ldr r4, [r1]

9 ldr r5, [r1]

10 ldr r6, [r1]

11 ldr r7, [r1]

12 stmia r0!, {r4-r7}

13 ldr r4, [r1]

14 ldr r5, [r1]

15 ldr r6, [r1]

16 ldr r7, [r1]

17 stmia r0!, {r4-r7}

18 ldr r4, [r1]

19 ldr r5, [r1]

20 ldr r6, [r1]

21 ldr r7, [r1]

22 stmia r0!, {r4-r7}

23 ldr r4, [r1]

24 ldr r5, [r1]

25 ldr r6, [r1]

26 ldr r7, [r1]

27 stmia r0!, {r4-r7}

28 subs r2, r2, #64 @ 一次循环读64个字节

29 bne 1b;

30 ldmfd sp!, {r2-r7} @ 恢复r2~r7寄存器的值

31 mov pc,lr @ 返回

挺好懂的，不多解析。再回到Main()函数的17行(最后一个函数调用)调用ReadImageFromNand()：

1 void ReadImageFromNand(void)

2 {

3 unsigned int Length;

4 U8 *RAM;

5 unsigned BlockNum;

6 unsigned pos;

7

8 Length = g_os_length;

9 //内核的大小(单位：块)

10 Length = (Length + BLOCK_SIZE - 1) >> (BYTE_SECTOR_SHIFT + SECTOR_BLOCK_SHIFT) << (BYTE_SECTOR_SHIFT + SECTOR_BLOCK_SHIFT); // align to Block Size

11 //内核在flash中的第几块

12 BlockNum = g_os_start >> (BYTE_SECTOR_SHIFT + SECTOR_BLOCK_SHIFT);

13 //要拷贝到的起始地址

14 RAM = (U8 *) g_os_ram_start;

15 for (pos = 0; pos < Length; pos += BLOCK_SIZE) {

16 unsigned int i;

17 // skip badblock

18 //坏块检测

19 for (;;) {

20 if (NandIsGoodBlock

21 (BlockNum <<

22 (BYTE_SECTOR_SHIFT + SECTOR_BLOCK_SHIFT))) {

23 break;

24 }

25 BlockNum++; //try next

26 }

27 for (i = 0; i < BLOCK_SIZE; i += SECTOR_SIZE) {

28 int ret =

29 NandReadOneSector(RAM,

30 (BlockNum <<

31 (BYTE_SECTOR_SHIFT +

32 SECTOR_BLOCK_SHIFT)) + i);

33 RAM += SECTOR_SIZE;

34 ret = 0;

35

36 }

37

38 BlockNum++;

39 }

40

41 CallLinux();

42 }

主要是从nand flash里把内核映像一块一块地读到ram里，每读一块之前先进行坏块检测，如果是坏块就跳过，继续读下一块(这里的坏块检测是一个比较粗略的检测方法)，直到把整个内核映像读到ram里面。这里内核映像的大小设置为3M(实际上不到3M)，因此读也是读3M大小到ram里面。最后该函数的第41行调用CallLinux()：

1 static void CallLinux(void)

2 {

3 struct param_struct {

4 union {

5 struct {

6 unsigned long page_size; /* 0 */

7 unsigned long nr_pages; /* 4 */

8 unsigned long ramdisk_size; /* 8 */

9 unsigned long flags; /* 12 */

10 unsigned long rootdev; /* 16 */

11 unsigned long video_num_cols; /* 20 */

12 unsigned long video_num_rows; /* 24 */

13 unsigned long video_x; /* 28 */

14 unsigned long video_y; /* 32 */

15 unsigned long memc_control_reg; /* 36 */

16 unsigned char sounddefault; /* 40 */

17 unsigned char adfsdrives; /* 41 */

18 unsigned char bytes_per_char_h; /* 42 */

19 unsigned char bytes_per_char_v; /* 43 */

20 unsigned long pages_in_bank[4]; /* 44 */

21 unsigned long pages_in_vram; /* 60 */

22 unsigned long initrd_start; /* 64 */

23 unsigned long initrd_size; /* 68 */

24 unsigned long rd_start; /* 72 */

25 unsigned long system_rev; /* 76 */

26 unsigned long system_serial_low; /* 80 */

27 unsigned long system_serial_high; /* 84 */

28 unsigned long mem_fclk_21285; /* 88 */

29 } s;

30 char unused[256];

31 } u1;

32 union {

33 char paths[8][128];

34 struct {

35 unsigned long magic;

36 char n[1024 - sizeof(unsigned long)];

37 } s;

38 } u2;

39 char commandline[1024];

40 };

41 //启动参数在内存的起始地址

42 struct param_struct *p = (struct param_struct *)0x30000100;

43 memset(p, 0, sizeof(*p));

44 memcpy(p->commandline, g_linux_cmd_line, sizeof(g_linux_cmd_line));

45 //内存页的大小4K

46 p->u1.s.page_size = 4 * 1024;

47 //内存总共有多少页

48 p->u1.s.nr_pages = 64 * 1024 * 1024 / (4 * 1024);

49

50 {

51 unsigned int *pp = (unsigned int *)(0x30008024);

52 if (pp[0] == 0x016f2818) { //zImage的魔数，在内核中定义

53 //Uart_SendString("\n\rOk\n\r");

54 } else {

55 Uart_SendString("\n\rWrong Linux Kernel\n\r");

56 for (;;) ;

57 }

58

59 }

60 asm (

61 "mov r5, %2\n"

62 "mov r0, %0\n"

63 "mov r1, %1\n"

64 "mov ip, #0\n"

65 "mov pc, r5\n"

66 "nop\n" "nop\n": /* no outpus */

67 :"r"(0), "r"(782), "r"(g_os_ram_start)

68 );

69 }

首先定义了一个struct param_struct结构体变量，从这里就可以看出，vboot用的是旧的方式(新的是用tag方式)，struct param_struct与内核里定义的一样。第41~59行，看注释可以明白，第60~67行，是内核的一些约定：

R0 = 0

R1 = 机器ID

.....

最后第65行，设置pc为内核映像在内存中的起始地址，直接跳到内核映像的入口，从而开始内核代码的执行......

总结：

vboot是一个十分精简的bootloader，从nand flash启动，目前只支持2440 Linux，只有引导内核的功能，它的编译后的二进制文件不会超过4K(这是由2440从nand flash启动所限制的)，编译vboot只需要在代码目录下执行make，便可生成vboot.bin文件，通过BIOS将它烧写到nand flash里。强烈推荐想学习ARM bootloader的同学从vboot开始入手。