自己动手写最简单的bootloader

首先我们必须要知道,一开始我们的开发板上电的时候, 如果我们的板子是从norflash启动的,那么硬件会从nandflash拷贝其前4k的代码到内部RAM中, (这也是为什么我们的bootloader第一阶段需要在4k内),如果是norflash启动,那也是从norflash把前4k代码复制到内部RAM中

我们知道mini2440有个看门狗,如果说我们不能够定时去喂狗, 那么它会在超时的时候自动重启(硬件决定的),所以我们的bootloader的第一步就是

①     关闭看门狗

2440在启动的时候他是直接以外部晶振直接作为系统时钟,所以系统运行在12MHz的,这个频率实在是太小了, 所以我们为了让我们的板子运行速度加快,那么我们第二步就是

②     修改板子的时钟频率

在接下来我们想想要做什么呢?我们是不是想要启动内核,那启动内核之前是不是需要先把内核从nandflash(内核是放在nandflash的0x60000的)拷贝到内存SDRAM中,而这个SDRAM(64M)在进行读写前是需要你先去初始化他的一些存储单元才能够正常的进行读写的!!!!所以我们的第三部就是

③     初始化SDRAM

我们把内核拷贝到SDRAM前,得先初始化nandflash, 才能够写nandflash,所以:

④     初始化nandflash

接下来由于我们后面的操作是使用了c语言,故我们先要设置栈sp

⑤     设置栈sp

那么我们接下来是不是就是去把内核拷贝到SDRAM中呢?别急,我们要知道我们的bootloader目前只有前4k的代码被拷贝到内部RAM中,如果说我们的bootloader超过4k的话那么我们的bootloader就很有可能会出问题, 所以我们接下来要做的就是拷贝bootloader到SDRAM中,再跳过去运行, 这叫做:

⑥     重定位

重定位结束后,我们需要先清除bss段,也就是赋值为0, 具体什么是bss段这里就不解释了

⑦     清bss段

接下来进入bootloader第二阶段

接下来我们终于到了把内核从nandflash中拷贝到SDRAM中,这就涉及到读nandflash了,而nandflash读的时候呢,需要我们先去

⑧     为了调试方便我们在这里初始化串口, 让串口能够为我们打印一下提示信息

⑨     把内核从nandflash拷贝到SDRAM中

⑩     设置好传递给内核的参数  调用内核

接下来讲解具体的代码, 首先是 start.s 这个是第一阶段的文件.

[cpp] view plain copy

1. .text  
2. .global _start  
3. _start:  
4. /*①关看门狗*/  
5.     ldr r0 ,= 0x53000000  
6.     mov r1 , #0  
7.     str r1 , [r0]  
8. /* ②设置时钟 ,因为他本来的时钟频率为12mhz 太低*/  
9.     ldr r0 ,= 0x4c000014  /*CLKDIVN*/  
10.     mov r1 , #0x5           /*#5     F:H:P = 1 : 4:8*/  
11.     str r1 , [r0]  
12.     /*数据手册说的, 设置异步模式*/  
13.       
14. /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */  
15.         mrc p15, 0, r1, c1, c0, 0       /* 读出控制寄存器 */   
16.         orr r1, r1, #0xc0000000         /* 设置为“asynchronous bus mode” */  
17.         mcr p15, 0, r1, c1, c0, 0       /* 写入控制寄存器 */  
18.       
19. /* MPLLCON = S3C2440_MPLL_400MHZ */  
20.     ldr r0 ,= 0x4c000004  
21.     ldr r1 ,= ((0x7f<<12)|(0x2<<4)|0x1) /* 设置为400mhz*/  
22.     str r1,[r0]  
23.   
24. /* 启动ICACHE,  此步骤可以没有, 加上的原因是因为这样能够让启动速度加快 */  
25.     mrc p15, 0, r0, c1, c0, 0   @ read control reg  
26.     orr r0, r0, #(1<<12)  
27.     mcr p15, 0, r0, c1, c0, 0   @ write it back  
28.   
29.   
30.   
31. /* ③初始化SDRAM*/  
32.     ldr r0 ,= 0x48000000  
33.     adr r1 ,sdram_config  
34.     add r3 , r0 ,#(13*4)  
35. 0:  
36.     ldr r2 , [r1] ,#4  
37.     str r2 , [r0]  ,#4  
38.     cmp r0,r3  
39.     bne 0b  
40.   
41. /*  led  此步骤可以不要 , 只是一开始用于调试, 点灯看看程序运行状况 */  
42.     ldr r0 ,= 0x56000010  
43.     ldr r1 ,= (0x55<<10)  
44.     str r1,[r0]   
45. /* ④ 设置栈 */  
46.     ldr sp,=0x34000000  /*0x34000000这是sdram的结束地址,栈的设置 很重要 , 设置错误 很容易导致系统重启*/  
47.     bl uart0_init  /*初始化串口, 之所以把这个放到这里, 主要原因是为了方便调试*/  
48. /*⑤初始化nandflash*/  
49.     bl nand_init  
50. /*⑥重定位*/  
51.     mov r0 , #0  
52.     ldr r1 ,= 0x33f80000  @_start    @0x33f80000  
53.     ldr r2 ,= __bss_start     
54.     @sub r2 , r2 , r1  
55.   
56.     bl copy_code_to_sdram  /*上面的r0-r2是参数*/  
57.       
58.     bl clear_bss /*清 bss 段*/      
59.   
60.     /*goto main*/  
61.     ldr lr ,= halt  
62.     ldr pc ,= Main  
63.     bl led_on  
64.   
65. halt:  
66.     b halt  
67.           
68.   
69. sdram_config:  
70.     .long 0x22011110       
71.     .long 0x00000700       
72.     .long 0x00000700       
73.     .long 0x00000700       
74.     .long 0x00000700       
75.     .long 0x00000700       
76.     .long 0x00000700       
77.     .long 0x00018005       
78.     .long 0x00018005       
79.     .long 0x008C04F4       
80.     .long 0x000000B1       
81.     .long 0x00000030       
82.     .long 0x00000030       

首先看我们的uart_init()初始化串口:

[cpp] view plain copy

1. void uart0_init(void)  
2. {  
3. GPHCON = (GPHCON&(~(0xf<<4)))|(0xa<<4);// GPH2,GPH3用作TXD0,RXD0    
4. UFCON0 = 0x00;   //不使用FIFO  
5. UMCON0 = 0x00;   //不使用自动流控制  
6. ULCON0 = 0x03;   //不采用红外线传输模式，无奇偶校验位，1个停止位，8个数据位  
7. UCON0  = 0x05;   //发送中断为电平方式，接收中断为边沿方式，禁止超时中断，允许产生错误状态中断，禁止回送模式，禁止中止信号          //信号，传输模式为中断请求模式，接收模式也为中断请求模式。  
8. UBRDIV0=((int)(50000000/(UART_BAUD_RATE*16))-1); //根据波特率计算UBRDIV0的值    
9.   
10. }  

串口设置好后, 很明显我们需要写串口输出的函数:

[cpp] view plain copy

1. /* 发送一个字符 */  
2. void _putc(char c)  
3. {  
4.     /* 等待，直到发送缓冲区中的数据已经全部发送出去 */  
5.     while (!(UTRSTAT0 & TXD0READY));  
6.       
7.     /* 向UTXH0寄存器中写入数据，UART即自动将它发送出去 */  
8.     UTXH0 = c;  
9. }  
10. /*发送字符串*/  
11. void _puts(char *str)  
12. {  
13.  while(*str){  
14.   _putc(*str++);  
15.  }  
16. }  

先贴下宏定义:

[cpp] view plain copy

1. #define uchar  unsigned char   
2. #define uint   unsigned int   
3. /* NAND FLASH控制器 */  
4. #define NFCONF (*((volatile unsigned long *)0x4E000000))  
5. #define NFCONT (*((volatile unsigned long *)0x4E000004))  
6. #define NFCMMD (*((volatile unsigned char *)0x4E000008))  
7. #define NFADDR (*((volatile unsigned char *)0x4E00000C))  
8. #define NFDATA (*((volatile unsigned char *)0x4E000010))  
9. #define NFSTAT (*((volatile unsigned char *)0x4E000020))  
10.   
11. /* GPIO */  
12. #define GPHCON              (*(volatile unsigned long *)0x56000070)  
13. #define GPHUP               (*(volatile unsigned long *)0x56000078)  
14.   
15. /* UART registers*/  
16. #define ULCON0              (*(volatile unsigned long *)0x50000000)  
17. #define UCON0               (*(volatile unsigned long *)0x50000004)  
18. #define UFCON0              (*(volatile unsigned long *)0x50000008)  
19. #define UMCON0              (*(volatile unsigned long *)0x5000000c)  
20. #define UTRSTAT0            (*(volatile unsigned long *)0x50000010)  
21. #define UTXH0               (*(volatile unsigned char *)0x50000020)  
22. #define URXH0               (*(volatile unsigned char *)0x50000024)  
23. #define UBRDIV0             (*(volatile unsigned long *)0x50000028)  
24.   
25. #define PCLK            50000000    // init.c中的clock_init函数设置PCLK为50MHz  
26. #define UART_CLK        PCLK        //  UART0的时钟源设为PCLK  
27. #define UART_BAUD_RATE  115200      // 波特率  
28. #define UART_BRD        ((UART_CLK  / (UART_BAUD_RATE * 16)) - 1)  
29.   
30. #define u32 unsigned long   
31.   
32. #define TXD0READY   (1<<2)  

接下来我们看看nandflash的初始化函数nand_init()

[cpp] view plain copy

1. void nand_init(){  
2. #define TACLS   0  
3. #define TWRPH0  1    //  hclk * (twrph0+1)  = 0.1ns * (twrph0 + 1)>=12  
4. #define TWRPH1  0  
5.     /* 设置时序  上面的三个宏的设置请参考数据手册, 具体说明:<a href="http://hi.baidu.com/kqalowgkkceqvys/item/f6406fdb731fdef593a97404">http://hi.baidu.com/kqalowgkkceqvys/item/f6406fdb731fdef593a97404</a>*/  
6.     NFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4 );  
7.     /* 使能nand flash 控制器, 初始化ECC,  禁止片选 */  
8.     NFCONT = (1<<4)|(1<<1)|(1<<0);      
9. }  

接下来到了copy_code_to_sdram(), 也就是重定位

[cpp] view plain copy

1. void copy_code_to_sdram(uchar* src_addr,uchar* dest,uint len){  
2.     /* 判断从哪里启动  */  
3.     uint i = 0;  
4.     _puts("copy_code_to_sdram\n\r");  
5.     if(isBootFromNorFlash()){// 如果是从norflash启动, 直接拷贝  
6.         _puts("NorFlash\n\r");  
7.         while(i<len){  
8.             *dest++ = *src_addr++;  
9.             i++;  
10.         }  
11.     }else{    
12.         _puts("Nand Flash\n\r");  
13.         nand_read((uint)src_addr,dest,len);//下面解释  
14.     }  
15.     _puts("copy_code_to_sdram end .................\n\r");  
16. }  

nandflash的读操作是要参考数据手册的,

1. 片选
2. 发送00h命令
3. 发送地址5周期
4. 发送读命令 30h
5. 判断状态
6. 读..
7. 取消片选

[cpp] view plain copy

1. void nand_read(uint src_addr,uchar* dest,uint len){  
2.     uint i = 0 , j=0;  
3.     int col = src_addr%2048;  
4.     /*片选*/  
5.     nand_select();  
6.       
7.     while(i < len){  
8.         /*发出读命令00h*/  
9.         nand_cmd(0x0);  
10.         /*发出地址(5个周期)*/  
11.         nand_addr(src_addr);  
12.         /*发出读命令30h*/  
13.         nand_cmd(0x30);  
14.         /*判断状态*/  
15.         nand_wait_ready();  
16.         /*读数据*/  
17.       
18.         for(;(col<2048)&&(i<len);col++){            
19.             dest[i++] = nand_data();  
20.         }  
21.         if(!((j++)%20))  
22.             _putc('#');// 打印提示  
23.         col = 0;  
24.       
25.     }  
26.     /*取消片选*/  
27.     nand_disselect();  
28.     _puts("\n\r");  
29.     _puts("nand_read end\n\r");  
30. }  

 

[cpp] view plain copy

1. void nand_cmd(uchar cmd){/*发送nand命令*/  
2.     volatile int i = 10;  
3.     NFCMMD  = cmd;  
4.     while(i--);  
5. }  
6.   
7. void nand_addr(uint addr){/*发送nand地址, 5个周期, 具体参考对应的数据手册*/  
8.     uint col  = addr % 2048;  
9.     uint page = addr / 2048;  
10.     volatile int i;  
11.     NFADDR = col&0xff;  
12.     for(i = 10 ;i; i--);  
13.     NFADDR = (col>>8)&0xff;  
14.     for(i = 10 ;i; i--);  
15.     NFADDR = page&0xff;  
16.     for(i = 10 ;i; i--);  
17.     NFADDR = (page>>8)&0xff;  
18.     for(i = 10 ;i; i--);  
19.     NFADDR = (page>>16)&0xff;  
20.     for(i = 10 ;i; i--);  
21. }  
22.   
23. void nand_wait_ready(){  
24.     while(!(NFSTAT&1));  
25. }  
26.   
27. uchar nand_data(){/*读取数据*/  
28.     return NFDATA;  
29. }  
30.   
31. void nand_select(){/*片选*/  
32.     NFCONT &= ~(1<<1);  
33. }  
34. void nand_disselect(){/*取消片选*/  
35.     NFCONT |= (1<<1);  
36. }  

 接下来是清bss段

[cpp] view plain copy

1. void clear_bss()  
2. {  
3.     extern int __bss_start , __bss_end;  
4.     int *p = &__bss_start;  
5.     _puts("clear_bss\n\r");  
6.     while(p<&__bss_end){  
7.         *p++ = 0;  
8.     }  
9. }  

好啦, 我们跳到Main函数, 也就是我们的第二阶段啦:

[cpp] view plain copy

1. void Main(){  
2.     void    (*theKernel)(int zero, int arch, uint params);  
3.   
4.     /*1. 从nand flash 里把内核读到内存*/  
5.     nand_read(0x60000, (uchar *)0x30008000, 0x500000);/*从0x600000拷贝0x500000 = 5M到0x30008000去*/    
6.     /*2. 设置参数*/  
7.     _puts("set params \n\r");  
8.     setup_start_tag ();  
9.     setup_memory_tags ();  
10.     setup_commandline_tag ("noinitrd root=/dev/mtdblock2 init=/linuxrc console=ttySAC0");  
11.     setup_end_tag ();  
12.   
13.       
14.     /*3. 跳转执行*/  
15.     _puts("boot kernel \n\r");  
16.     theKernel = (void (*)(int ,int ,uint))(0x30008000);  
17.     theKernel (0, 1999, 0x30000100);  
18.   
19.     _puts("error............. \n\r");  
20.       
21. }  

 

[cpp] view plain copy

1. static struct tag *params;  
2.   
3. static void setup_start_tag ()  
4. {  
5.     params = (struct tag *)0x30000100;  
6.   
7.     params->hdr.tag = ATAG_CORE;  
8.     params->hdr.size = tag_size (tag_core);  
9.     params->u.core.flags = 0;  
10.     params->u.core.pagesize = 0;  
11.     params->u.core.rootdev = 0;  
12.   
13.     params = tag_next (params);  
14. }  
15. static void setup_memory_tags ()  
16. {  
17.   
18.     params->hdr.tag = ATAG_MEM;  
19.     params->hdr.size = tag_size (tag_mem32);  
20.   
21.     params->u.mem.start = 0x30000000;  
22.     params->u.mem.size  = 64*1024*1024;  
23.   
24.     params = tag_next (params);  
25. }  
26.   
27. static uint _strlen(char *buf){  
28.     uint i=0;  
29.     while(*buf++){  
30.         i++;  
31.     }  
32.     return i;  
33. }  
34.   
35. static void my_strcpy(char * src ,char *dest){  
36.   
37.     while ((*dest++ = *src++) != '\0');  
38. }  
39. static void setup_commandline_tag ( char *commandline)  
40. {  
41.   
42.     int len = _strlen(commandline)+1;  
43.     _puts("setup_commandline_tag now \n\r");  
44.     params->hdr.tag = ATAG_CMDLINE;  
45.     params->hdr.size = (sizeof (struct tag_header) + len + 3) >> 2;/* 向4取整*/  
46.   
47.     my_strcpy(params->u.cmdline.cmdline, commandline);  
48.     params = tag_next (params);  
49. }  
50.   
51. static void setup_end_tag ()  
52. {  
53.     params->hdr.tag = ATAG_NONE;  
54.     params->hdr.size = 0;  
55. }  

最后附上链接脚本:

[cpp] view plain copy

1. SECTIONS {  
2.     . = 0x0;  
3.     .text : { *(.text) }  
4.       
5.     . = ALIGN(4);/*四字节对齐*/  
6.     .rodata : {*(.rodata)}   
7.       
8.     . = ALIGN(4);  
9.     .data : { *(.data) }  
10.       
11.     . = ALIGN(4);  
12.     __bss_start = .;  
13.     .bss : { *(.bss)  *(COMMON) }  
14.     __bss_end = .;  
15. }  

Makefile

[cpp] view plain copy

1. CC       := arm-linux-gcc  
2. LD       := arm-linux-ld  
3. AR       := arm-linux-ar  
4. OBJCOPY  := arm-linux-objcopy  
5. OBJDUMP  := arm-linux-objdump  
6. CFLAGS   := -Wall -O2  
7. CPPFLAGS := -nostdinc  
8.   
9.   
10. objs := start.o  init.o Main.o  
11. boot.bin:$(objs)  
12.     $(LD) -o boot.elf -Tboot.lds $^           # 链接  
13.     $(OBJCOPY) -O binary -S boot.elf $@       # 转为2进制  
14.     $(OBJDUMP) -D -m arm boot.elf > boot.dis  #  反汇编  
15.   
16. %.o:%.c  
17.     $(CC) -o $@ -c $< $(CPPFLAGS) $(CFLAGS)   
18.   
19. %.o:%.s  
20.     $(CC) -o $@ -c $< $(CPPFLAGS) $(CFLAGS)   
21.   
22. clean:  
23.     rm -r *.o *.elf *.bin *.dis  

代码: