最简 bootloader

文章主题

bootloader 是什么？如果你看到了这篇文章，肯定已经知道答案了，所以这里就不赘述了。这篇文章主要是根据韦东山老师的视频，从零开始写一个最简单的 bootloader，每一行代码都是手动输入。虽然直接看一遍视频，也能够理解其中的步骤或者原理，但是根据视频敲一遍之后，印象才是最深刻的。

内容导航

• 测试平台
• 文件目录结构
• 代码详解
• 一些操作指令和流程

测试平台

开发环境：电脑 MAC Pro,安装2个虚拟机 Windows7 和Ubuntu14.04。

• Win7: 用于代码编辑（SourceInsight）和烧录裸板程序（oflash）。需要安装驱动程序：OpenJTAG 驱动，PL2303 USB 转串口驱动。
• Ubuntu14.04：用于交叉编译，交叉编译工具链直接使用光盘里提供的 arm-linux-gcc 即可。
• 文件传送：Win7 与 Ubuntu 之间的文件复制使用 SecureCRT。

开发板：JZ2440-V3，这块板子上已经集成了 USB转串口芯片。

烧录工具：OpenJTAG，连接开发板的 JTAG 接口即可。

测试工具：串口，直接连接 MicroUSB 口到 PC 的 USB 口，串口工具 SecureCRT。

文件目录结构

start.S：第一个启动的程序，完成的功能是：

init.c：串口的初始化和发送数据，NandFlash 的初始化和读取数据，BSS 段初始化。

setup.h：主要是定义了向内核传递参数时所需要的 tag 结构体。

boot.c：main 函数，设置 bootloader 向内核传递的启动参数。

boot.lds：连接脚本。

Makefile：make 编译指令。

代码详解

我比较赞成“代码即注释”这样的编程风格，只要看代码中的注释，就能明白其中的逻辑。所以，这里只贴出代码，不再进行进一步解释说明了。

1、start.S

1. #define S3C2440_MPLL_200MHZ ((0x5c<<12) | (0x01<<4) | (0x02))
2. #define MEM_CTL_BASE 0x48000000
4. .text
5. .global _start
6. _start:
8. /* 1. 关看门狗 */
9. ldr r0, =0x53000000
10. mov r1, #0
11. str r1, [r0]
13. /* 2. 设置时钟 */
14. ldr r0, =0x4c000014
15. mov r1, #0x03 /* FLCK:HCLK:PCLK = 1:2:4, HDIVN=1, PDIVN=1*/
16. str r1, [r0]
18. /* 如果 HDIVN 非0, CPU 的总线模式应该从 "fast bus mode" 改为 "asynchronous bus mod"*/
19. mrc p15, 0, r1, c1, c0, 0 /* 读出控制寄存器 */
20. orr r1, r1, #0xc0000000 /* 设置为 "asynchronous bus mod" */
21. mcr p15, 0, r1, c1, c0, 0 /* 写入控制寄存器 */
23. /* 设置 MPLLCON */
24. ldr r0, =0x4c000004
25. ldr r1, =S3C2440_MPLL_200MHZ
26. str r1, [r0]
28. /* 3. 初始化SDRAM */
29. ldr r0, =MEM_CTL_BASE
30. adr r1, sdram_config
31. add r3, r0, #(13*4)
32. 1:
33. ldr r2, [r1], #4
34. str r2, [r0], #4
35. cmp r0, r3
36. bne 1b /* b表示向前跳转到标号1的地方*/
38. /* 4. 重定位：把bootloader本身的代码，从flash复制到它的链接地址上去 */
39. ldr sp, =0x34000000 /* 把堆栈设置为 SDRAM 的最顶端，因为是向下增长的 */
41. bl nand_init /* 初始化 NAND Flash */
43. mov r0, #0 /* 第一个参数：源地址 */
44. ldr r1, =_start /* 第二个参数：目标地址，即链接地址*/
45. ldr r2, =__bss_start
46. sub r2, r2, r1 /* 第三个参数：代码长度*/
47. bl copy_code_to_sdram /* 调用代码拷贝函数 */
49. bl clean_bss /* 调用 bss 段清零函数 */
51. /* 5. 执行 main */
52. ldr lr, =halt
53. ldr pc, =main
55. halt:
56. b halt
58. /* SDRAM 13 个控制器的值 */
59. sdram_config:
60. .long 0x22011110 // BWSCON
61. .long 0x00000700 // BANKCON0
62. .long 0x00000700 // BANKCON1
63. .long 0x00000700 // BANKCON2
64. .long 0x00000700 // BANKCON3
65. .long 0x00000700 // BANKCON4
66. .long 0x00000700 // BANKCON5
67. .long 0x00018005 // BANKCON6
68. .long 0x00018005 // BANKCON7
69. .long 0x008c04f4 // REFRESH
70. .long 0x000000b1 // BANKSIZE
71. .long 0x00000030 // MRSRB6
72. .long 0x00000030 // MRSRB7

2、init.c

2. /* Nand Flash 相关寄存器 */
3. #define NFCONF (*((volatile unsigned long *)0x4E000000))
4. #define NFCONT (*((volatile unsigned long *)0x4E000004))
5. #define NFCMMD (*((volatile unsigned char *)0x4E000008))
6. #define NFADDR (*((volatile unsigned char *)0x4E00000C))
7. #define NFDATA (*((volatile unsigned char *)0x4E000010))
8. #define NFSTAT (*((volatile unsigned char *)0x4E000020))
10. /* 串口 GPIO 配置*/
11. #define GPHCON (*((volatile unsigned char *)0x56000070))
12. #define GPHUP (*((volatile unsigned char *)0x56000078))
14. /* 串口寄存器 */
15. #define ULCON0 (*(volatile unsigned long *)0x50000000)
16. #define UCON0 (*(volatile unsigned long *)0x50000004)
17. #define UFCON0 (*(volatile unsigned long *)0x50000008)
18. #define UMCON0 (*(volatile unsigned long *)0x5000000c)
19. #define UTRSTAT0 (*(volatile unsigned long *)0x50000010)
20. #define UTXH0 (*(volatile unsigned char *)0x50000020)
21. #define URXH0 (*(volatile unsigned char *)0x50000024)
22. #define UBRDIV0 (*(volatile unsigned long *)0x50000028)
24. #define PCLK 50000000 // init.c
25. #define UART_CLK PCLK // UART0 的时钟源设置为 PCLK
26. #define UART_BAUD_RATE 115200 // 波特率
27. #define UART_BRD ((UART_CLK / (UART_BAUD_RATE * 16)) - 1)
31. #define TXD0READY (1<<2)
32. #define RXD0READY (1)
34. extern void nand_read(unsigned int addr, unsigned char*buf, unsigned int len);
36. /* UART0 初始化 */
37. void uart0_init(void)
38. {
39. GPHCON |= 0xa0; // GPH2,GPH3 用作 TXD0,RXD0
40. GPHUP = 0x0c; // GPH2,GPH3内部上拉
42. ULCON0 = 0x03; // 8N1
43. UCON0 = 0x05; //查询方式，UART时钟源为 PCLK
44. UFCON0 = 0x00; // 不适用FIFO
45. UMCON0 = 0x00; // 不使用流控
46. UBRDIV0 = UART_BRD; // 波特率115200
47. }
49. /*
50. * 发送一个字符
51. */
52. void putc(unsigned char c)
53. {
54. /* 等待，直到发送缓冲区中的数据已经全部发送出去 */
55. while (!(UTRSTAT0 & TXD0READY));
57. /* 向 UTXH0 寄存器中写入数据，UART即自动将它发送出去 */
58. UTXH0 = c;
59. }
61. unsigned char getc(void)
62. {
63. /* 等待，直到接受缓冲区有数据 */
64. while (!(UTRSTAT0 & RXD0READY));
66. /* 直接读取 URXH0 寄存器，即可获得接收到的数据 */
67. return URXH0;
68. }
70. void puts(char *str)
71. {
72. int i = 0;
73. while(str[i])
74. {
75. putc(str[i]);
76. i++;
77. }
78. }
80. /*
81. * Check if boot from Nor Flash
82. * Return: 1-Yes, 0-No
83. */
84. int isbootFromNorFlash(void)
85. {
86. volatile int *p = (volatile int *)0;
87. int val;
89. val = *p;
90. *p = 0x12345678;
91. if (*p == 0x12345678)
92. {
93. /* write data success, boot form Nand Flash */
94. *p = val;
95. return 0;
96. }
97. else
98. {
99. /* write data failed, boot from Nor Flash */
100. return 1;
101. }
102. }
104. /*
105. * Init Nand Flash Device
106. * Return: None
107. */
108. void nand_init(void)
109. {
110. /* NandFlash 的读写需要满足一定的时序，
111. 首先查找 NAND FLASH 手册，确定每个信号需要持续的时间，以及两个信号之间需要等待的时间。
112. 然后查找 2440 手册，确定这些时间要设置的是哪个寄存器的哪些bit位，然后通过公式计算出应该设置的值*/
113. #define TACLS 0
114. #define TWRPH0 3
115. #define TWRPH1 0
117. /* 设置时序*/
118. NFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4);
120. /* 使能 NAND FLASH 控制器，初始化 ECC, 禁止片选 */
121. NFCONT = (1<<4)|(1<<1)|(1<<0);
122. }
124. void nand_select(void)
125. {
126. NFCONT &= ~(1 << 1);
127. }
129. void nand_deselect(void)
130. {
131. NFCONT |= (1 << 1);
132. }
134. void nand_cmd(unsigned char cmd)
135. {
136. unsigned int i;
137. NFCMMD = cmd;
138. for (i = 0;i < 10; i++);
139. }
141. void nand_addr(unsigned int addr)
142. {
143. volatile unsigned int i;
144. unsigned int col = addr % 2048;
145. unsigned int page = addr / 2048;
147. /* 发出列地址 */
148. NFADDR = col & 0xFF;
149. for (i = 0;i < 10; i++);
150. NFADDR = (col >> 8) & 0xFF;
151. for (i = 0;i < 10; i++);
153. /* 发出行地址，也就是页地址 */
154. NFADDR = page & 0xFF;
155. for (i = 0;i < 10; i++);
156. NFADDR = (page >> 8) & 0xFF;
157. for (i = 0;i < 10; i++);
158. NFADDR = (page >> 16) & 0xFF;
159. for (i = 0;i < 10; i++);
160. }
162. void nand_wait_ready(void)
163. {
164. while (!(NFSTAT & 1));
165. }
167. char nand_data(void)
168. {
169. return NFDATA;
170. }
172. /*
173. * Read data from Nand Flash
174. * Return: None
175. */
176. void nand_read(unsigned int addr, unsigned char*buf, unsigned int len)
177. {
178. unsigned int i = 0;
179. int col = addr%2048;
181. /* 1. 选中 */
182. nand_select();
184. while (i < len)
185. {
186. /* 2. 发出读命令 0x00 */
187. nand_cmd(0x00);
189. /* 3. 发出地址（分5步发出） */
190. nand_addr(addr);
192. /* 4. 发出读命令 0x30 */
193. nand_cmd(0x30);
195. /* 5. 判断状态 */
196. nand_wait_ready();
198. /* 6. 读数据 */
199. for (; (col < 2048) && (i < len); col++)
200. {
201. buf[i] = nand_data();
202. i++;
203. addr++;
204. }
205. col = 0;
206. }
208. /* 7. 取消选中 */
209. nand_deselect();
210. }
212. /*
213. * Copy code from NorFlash or NandFlash to SDRAM
214. * Return: None
215. */
216. void copy_code_to_sdram(unsigned char *src, unsigned char *dest, unsigned int len)
217. {
218. unsigned int i = 0;
219. if (isbootFromNorFlash())
220. {
221. while (i < len)
222. {
223. dest[i] = src[i];
224. i++;
225. }
226. }
227. else
228. {
229. nand_read((unsigned int)src, dest, len);
230. }
231. }
233. /*
234. * Clear BSS Section
235. * Return: None
236. */
237. void clean_bss(void)
238. {
239. extern int __bss_start, __bss_end;
240. int *p = &__bss_start;
241. for (; p < &__bss_end; p++)
242. *p = 0;
243. }

3、setup.h

主要是 tag 数据结构，这里就不贴全部代码了，如果需要可以直接从 uboot 的源码里找到这个文件。

1. struct tag {
2. struct tag_header hdr;
3. union {
4. struct tag_core core;
5. struct tag_mem32 mem;
6. struct tag_videotext videotext;
7. struct tag_ramdisk ramdisk;
8. struct tag_initrd initrd;
9. struct tag_serialnr serialnr;
10. struct tag_revision revision;
11. struct tag_videolfb videolfb;
12. struct tag_cmdline cmdline;
14. /*
15. * Acorn specific
16. */
17. struct tag_acorn acorn;
19. /*
20. * DC21285 specific
21. */
22. struct tag_memclk memclk;
23. } u;
24. };

4、boot.c

1. #include "setup.h"
3. static struct tag *params;
5. void setup_start_tag(void)
6. {
7. /* uboot与kernel约定好：在地址 0x30000100 的地方开始存放参数 */
8. params = (struct tag *)0x30000100;
9. params->hdr.tag = ATAG_CORE;
10. params->hdr.size = tag_size(tag_core);
12. params->u.core.flags = 0;
13. params->u.core.pagesize = 0;
14. params->u.core.rootdev = 0;
16. params = tag_next(params);
17. }
19. void setup_memory_tag(void)
20. {
21. params->hdr.tag = ATAG_MEM;
22. params->hdr.size = tag_size(tag_mem32);
24. params->u.mem.start = 0x30000000; // SDRAM 开始地址
25. params->u.mem.size = 64 * 1024 * 1024; // SDRAM 容量
27. params = tag_next(params);
28. }
30. int strlen(char *str)
31. {
32. int i = 0;
33. while (str[i]) i++;
34. return i;
35. }
37. void strcpy(char *dest, char *src)
38. {
39. while((*dest++ = *src++) != '\0');
40. }
42. void setup_commandline_tag(char *cmdline)
43. {
44. int len = strlen(cmdline) + 1;
45. params->hdr.tag = ATAG_CMDLINE;
46. params->hdr.size = (sizeof(struct tag_header) + len + 3)>>2;
47. strcpy(params->u.cmdline.cmdline, cmdline);
49. params = tag_next(params);
50. }
52. void setup_end_tag(void)
53. {
54. params->hdr.tag = ATAG_NONE;
55. params->hdr.size =0;
56. }
59. int main(void)
60. {
61. void (*theKernel)(int zero, int arch, unsigned int params);
63. /* 帮内核设置串口: 内核启动时，会从串口打印一些信息，但是内核一开始没有初始化串口 */
64. uart0_init();
65. puts("Sewain>> Init UART0 success \r\n");
67. /* 1. 从 NAD FLASH 里把内核读入内存。
68. 开发板中内核 uImage = Header(64B) + zImage(真正的内核)。
69. 参数1：uImage 的地址位于 0x00060000, 所以从这个地址之后的 64 字节，才是真正的内核文件。
70. 参数2：内核在编译时就固定了加载地址和运行地址都为 0x30008000(是距离 SDRAM 底部32K 的位置),所以第二个参数是写入这个地址。
71. 参数3：内核文件大概是 1.8M，这里直接读取 2M 的数据 */
72. puts("Sewain>> Copy kernel from nand flash \r\n");
73. nand_read(0x00060000 + 64, (unsigned char *)0x30008000, 0x00200000);
75. /* 2. 设置参数 */
76. puts("Sewain>> Set boot params \r\n");
77. setup_start_tag();
78. setup_memory_tag();
79. setup_commandline_tag("noinitrd root=/dev/mtdblock3 init=/linuxrc console=ttySAC0");
80. setup_end_tag();
82. /* 3. 跳转执行 */
83. puts("Sewain>> Boot kernel \r\n");
84. theKernel= (void (*)(int, int, unsigned int))0x30008000;
85. theKernel(0, 362, 0X3000100); /* 相当于： mov pc, #0x30008000 */
87. /* 如果一切正常，不应该执行到这里 */
88. puts("Sewain>> Error! You should NOT come here!! \r\n");
90. return -1;
91. }

5、boot.lds

这里的 0x33f80000 是位于开发板上 SDRAM 上的空间，距离底部 15M+512K 的地址，意思就是编译出来的程序的加载地址是 0x33f80000。

1. SECTIONS {
2. . = 0x33f80000;
3. .text : { *(.text) }
5. . = ALIGN(4);
6. .rodata : { *(.rodata*) }
8. . = ALIGN(4);
9. .data : { *(.data) }
11. . = ALIGN(4);
12. __bss_start = .;
13. .bss : { *(.bss) *(COMMON) }
14. __bss_end = .;
15. }

6、Makefile

2. CC = arm-linux-gcc
3. LD = arm-linux-ld
4. AR = arm-linux-ar
5. OBJCOPY = arm-linux-objcopy
6. OBJDUMP = arm-linux-objdump
8. INCLUDEDIR := $(shell pwd)/include
9. CFLAGS := -Wall -O2
10. CPPFLAGS := -nostdinc -nostdlib -fno-builtin
12. objs := start.o boot.o init.o
14. boot.bin: $(objs)
15. {LD} -Tboot.lds -o boot.elf ^
16. {OBJCOPY} -O binary -S boot.elf @
17. ${OBJDUMP} -D -m arm boot.elf > boot.dis
19. %.o: %.c
20. {CC} {CFLAGS} {CPPFLAGS} -c -o @
22. %.o: %.S
23. {CC} {CFLAGS} {CPPFLAGS} -c -o @
25. clean:
26. rm -f *.o *.bin *.elf *.dis

一些操作指令和流程

1、编译

通过 SecureCRT 把编辑好的代码复制到 Ubuntu 中，然后执行 make clean & make 编译，得到三个文件：boot.elf, boot.bin, boot.dis。

2. 烧写程序

把 boot.bin 复制到 Win7 中，然后通过命令行执行烧写工具 oflash boot.bin，根据提示符选择烧录到 Nand Flash 中。这期间会让你多次选择一些指令，看一下就明白了。

3. 验证

把开发板上的启动开关选择为 NAND，然后用串口工具 SecureCRT 连接到开发板，上电，可以看到一些信息，就是在 main 函数中写的那些打印信息。

总结

如果你需要上面的源码包，请联系我，非常乐意分享。

当然了，还是强烈建议你去看一下韦东山老师的视频教程，自己动手操作一遍之后，理解会更深刻。比如：如何配系统时钟、如何初始化串口、NandFlash 的存储和读写机制是怎么处理的等等。

1. 欢迎转载，请尊重版权，保留全部内容并注明来源。
2. 如果这篇文章侵犯了您的权益，请在此处或微信公众号留言，我会及时处理。
3. 如果需要一块探讨，请联系下面微信公众号【IOT物联网小镇】。