最简 bootloader

2021-05-13 11:36:03 浏览数 (5)

文章主题

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

代码语言：javascript复制
  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

代码语言：javascript复制
  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 48;
  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 的源码里找到这个文件。

代码语言：javascript复制
  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

代码语言：javascript复制
  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 ) != '');
  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 rn");
  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 rn");
  73. nand_read(0x00060000 64, (unsigned char *)0x30008000, 0x00200000);
  75. /* 2. 设置参数 */
  76. puts("Sewain>> Set boot params rn");
  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 rn");
  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!! rn");
  90. return -1;
  91. }

5、boot.lds

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

代码语言：javascript复制
  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

代码语言：javascript复制
  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物联网小镇】。
编程算法 flash 缓存 arm 单片机

0 人点赞