bootloader功能介绍/时钟初始化设置/串口工作原理/内存工作原理/NandFlash工作原理

bootloader功能介绍

初始化开发板上主要硬件（时钟，内存，硬盘），

把操作系统从硬盘拷贝到内存，然后让cpu跳转到内存中执行操作系统。

boot阶段

1.关闭影响CPU正常执行的外设

-关闭看门狗（watch dog）   WTCON 0xE2700000

-关闭中断 CPSR I和F位设置为1，关闭，不响应任何中断。

2.初始化时钟

-倍频到1Ghz，为外设分频

*串口驱动

3.初始化内存控制器，DDRAM

-验证内存，往里面写一个值，然后再读出来

4.初始化硬盘，nand Flash

-nand flash 读驱动（从nand往外读数据）

loader阶段

1.从硬盘指定的地址加载kernel到内存指定的地址。

2.跳转到内存kernel所在的地址，执行

附加功能：

实现bootloader中shell（命令解释器）

附加功能：

实现bootloader中shell（命令解释器）

uboot中支持的命令， 

help

loadb 下载程序， kermit 协议

go 0X21000000;

例如：在uboot中直接控制蜂鸣器

mm 0xe02000a0 0x1(控制寄存器)

mm 0xe02000a4 0x1(数据寄存器)

常用调试手段：

1.led点灯大法

2.串口调试，uart_getchar,uart_putchar,进一步实现stdio.h

时钟初始化设置

pll 锁相环， 倍频

串口工作原理

串口工作核心图

#define ULCON0 *((volatile unsigned int *)0XE2900000)

volatile 关键字，防止编译器做优化，每次读取寄存器的值，都是重新读取寄存器。

[cpp] view plain copy

print?

1. //start.s  
2.     AREA start_main,CODE, READONLY  
3.     ENTRY  
4.     IMPORT uart_test  
5. START  
6.     B uart_test  
7.       
8.     END  
9. //uart.c  
10. #define ULCON0 *((volatile unsigned int *)0XE2900000)  
11. #define UCON0 *((volatile unsigned int *)0XE2900004)  
12. #define UTRSTAT0 *((volatile unsigned int *)0XE2900010)  
13. #define UTXH0 *((volatile unsigned int *)0XE2900020)  
14. #define URXH0 *((volatile unsigned int *)0XE2900024)  
15. #define UBRDIV0 *((volatile unsigned int *)0XE2900028)  
16. #define UDIVSLOT0 *((volatile unsigned int *)0XE290002C)  
17. #define GPACON0 *((volatile unsigned int *)0XE0200000)  
18. void uart_init(void)  
19. {  
20.     //串口管脚设置成功能态  
21.     GPACON0 = 0x22;  
22.     //设置8  N  1  
23.     ULCON0 = 0X3;  
24.     //设置轮询工作模式  
25.     UCON0 = 0X5;  
26.     //设置波特率  
27.     UBRDIV0 = 34;  
28.     UDIVSLOT0 = 0XDDDD;  
29.       
30. }  
31. char uart_getchar(void)  
32. {  
33.     char ch;  
34.     //如果有数据到达，状态寄存器第0位置1  
35.     //判断状态位是否为1，决定读接收缓冲寄存器，读到的值作为函数的返回值  
36.     while (!(UTRSTAT0 & 0x1))  
37.         ;  
38.     ch = URXH0;  
39.     return ch;  
40. }  
41. void uart_putchar(char ch)  
42. {  
43.     //如果状态寄存器第1为置1，表示发送单元为空，可以发送数据  
44.     //把ch赋值到发送缓冲寄存器里，状态寄存器第1为置0， 自动发送，当发送完毕  
45.     while (!(UTRSTAT0 & 0X2))  
46.         ;  
47.     UTXH0 = ch;  
48. }  
49. void uart_test(void)  
50. {  
51.     char ch;  
52.       
53.     uart_init();  
54.     uart_putchar('a');  
55.     uart_putchar('b');  
56.     uart_putchar('c');  
57.     //串口回显功能  
58.     while (1)  
59.     {  
60.         ch = uart_getchar();  
61.         uart_putchar(ch);  
62.     }  
63. }  

内存工作原理

--------------------------------------------------

NandFlash工作原理

内存是总线设备，nandflash属于非总线设备。

没有地址线， 只有数据线。

内存：总线数据， nandflash：非总线设备。

命令、地址、数据复用端口。

忙闲位。

裸板操作NandFlash的示例代码：

[cpp] view plain copy

print?

1. #define NFCONF (*(volatile unsigned int *)0xB0E00000)  
2. #define NFCONT (*(volatile unsigned int *)0xB0E00004)  
3. #define NFCMMD (*(volatile unsigned int *)0xB0E00008)  
4. #define NFADDR (*(volatile unsigned int *)0xB0E0000C)  
5. #define NFDATA (*(volatile unsigned int *)0xB0E00010)  
6. #define NFSTAT (*(volatile unsigned int *)0xB0E00028)  
7.   
8. #define MP0_3CON (*(volatile unsigned int *)0xE0200320)  
9.   
10. #define PAGE_SIZE   2048  
11.   
12. void nand_init(void)  
13. {  
14.     //[15:12]TACLS = 1->(1) 1/133Mhz = 7.5ns  
15.     //[11:8] TWRPH0 = 1->(1+7) 7.5ns*2 = 15ns  
16.     //[7:4] TWRPH1 = 1->(1+1) 7.5ms *2 = 15ns  
17.     NFCONF |= 1<<2 | 1<< 8 | 1<< 4;  
18.     //AdrCycle [1]1=5 address cycle  
19.     NFCONF |= 1<<1;  
20.     //MODE [0] NAND Flash controller operating node  
21.     // 0=disable nand flash controller  
22.     // *1 = enable nand flash controller  
23.     NFCONT |= 1<<0;  
24.     //Reg_nCE0 [1] nandflash memort nRCS[0] signal control   
25.     // *0 = force nRCS[0] to low (enable chip select)  
26.     // 1 = force nRCS[0] to high(disable chip select)  
27.     NFCONT &= ~(1<<1);  
28.     //GPIO functional mux setting   
29.     // 0010 = NF_xxx  
30.     MP0_3CON = 0X22222222;  
31.     return ;      
32. }  
33.   
34. void nand_read_id(char id[])  
35. {  
36.     int i;  
37.     //write read_id cmd 90th  
38.     NFCMMD = 0X90;  
39.     //write address 00h  
40.     NFADDR = 0x00;  
41.     for(i=0; i<5; i++)  
42.     {  
43.         id[i] = NFDATA;  
44.     }  
45.     return ;  
46. }  
47.   
48. void nand_read_page(int addr, char buf[])  
49. {  
50.     int i;  
51.     char tmp;  
52.     //write read_page cmd 00h  
53.     NFCMMD = 0X00;  
54.     //write 5 address  
55.     NFADDR = (addr >> 0) & 0xFF;  
56.     NFADDR = (addr >> 8) & 0x7;  
57.     NFADDR = (addr >> 11) & 0xFF;  
58.     NFADDR = (addr >> 19) & 0xFF;  
59.     NFADDR = (addr >> 27) & 0x1;  
60.     //write read_page cmd 30h  
61.     NFCMMD = 0X30;  
62.     //wait for R/nB -->ready  
63.     while( (NFSTAT &(1<<0))==0 )  
64.         ;  
65.     //read data 2048 bytes  
66.     for(i=0; i<PAGE_SIZE; i++)  
67.     {  
68.         buf[i] = NFDATA;  
69.     }  
70.     for (i=0; i<64; i++)  
71.     {  
72.         tmp = NFDATA;  
73.     }  
74.     return ;  
75.       
76. }  
77.   
78. void nand_read(int nand_addr, char *sdram_addr, int size)  
79. {  
80.     int pages = (size -1)/PAGE_SIZE + 1;  
81.     int i;  
82.       
83.     for (i=0; i<pages; i++)  
84.     {  
85.         nand_read_page(nand_addr + i*PAGE_SIZE, sdram_addr + i*PAGE_SIZE);        
86.     }  
87.       
88. }  

uboot中操作NandFlash的示例代码：

//s3c2440_nand.c

[cpp] view plain copy

print?

1. #include <common.h>  
2.   
3. #if 0  
4. #define DEBUGN printf  
5. #else  
6. #define DEBUGN(x,args ...){}  
7. #endif  
8. #include <nand.h>  
9. #include <asm/arch/s3c24x0_cpu.h>  
10. #include <asm/arch/s3c2410.h>  
11. #include <asm/io.h>  
12.   
13. #define __REGb(x) (*(volatile unsigned char *)(x))  
14. #define __REGi(x)  (*(volatile unsigned int *)(x))  
15.   
16.   
17. #define NF_BASE         0x4e000000  
18.   
19. #define NFCONF           __REGi(NF_BASE + 0x0)  
20. #define NFCONT           __REGi(NF_BASE + 0x4)  
21. #define NFCMD            __REGb(NF_BASE + 0x8)  
22. #define NFADDR           __REGb(NF_BASE + 0xc)  
23. #define NFDATA           __REGb(NF_BASE + 0x10)  
24. #define NFMECCD0         __REGi(NF_BASE + 0x14)  
25. #define NFMECCD1         __REGi(NF_BASE + 0x18)  
26. #define NFSECCD          __REGi(NF_BASE + 0x1C)  
27. #define NFSTAT           __REGb(NF_BASE + 0x20)  
28. #define NFSTAT0          __REGi(NF_BASE + 0x24)  
29. #define NFSTAT1          __REGi(NF_BASE + 0x28)  
30. #define NFMECC0          __REGi(NF_BASE + 0x2C)  
31. #define NFMECC1          __REGi(NF_BASE + 0x30)  
32. #define NFSECC           __REGi(NF_BASE + 0x34)  
33. #define NFSBLK           __REGi(NF_BASE + 0x38)  
34. #define NFEBLK           __REGi(NF_BASE + 0x3C)  
35.   
36. #define S3C2440_NFCONT_nCE (1<<1)  
37. #define S3C2440_ADDR_NALE 0x08  
38. #define S3C2440_ADDR_NCLE 0x0c  
39.   
40.   
41.   
42. #ifdef CONFIG_NAND_SPL  
43.   
44. /* in the early stage of NAND flash booting, printf() is not available */  
45. #define printf(fmt, args...)  
46.   
47. static void nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)  
48. {  
49.     int i;  
50.     struct nand_chip *this = mtd->priv;  
51.   
52.     for (i = 0; i < len; i++)  
53.         buf[i] = readb(this->IO_ADDR_R);  
54. }  
55. #endif  
56.   
57. ulong  IO_ADDR_W = NF_BASE;   
58. static void s3c2440_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)  
59. {  
60.     struct nand_chip *chip = mtd->priv;  
61.     DEBUGN("hwcontrol(): 0x%02x 0x%02x\n", cmd, ctrl);  
62.     if (ctrl & NAND_CTRL_CHANGE) {  
63.         IO_ADDR_W = NF_BASE;  
64.         if (!(ctrl & NAND_CLE))  
65.                 IO_ADDR_W |= S3C2440_ADDR_NCLE;  
66.         if (!(ctrl & NAND_ALE))  
67.                 IO_ADDR_W |= S3C2440_ADDR_NALE;  
68.   
69.        if (ctrl & NAND_NCE)  
70.             NFCONT &= ~ S3C2440_NFCONT_nCE;  
71.        else  
72.             NFCONT |= S3C2440_NFCONT_nCE;   
73.     }  
74.     if (cmd != NAND_CMD_NONE)  
75.                 writeb(cmd, (void *)IO_ADDR_W);  
76. }  
77.   
78.   
79.   
80. static int s3c2440_dev_ready(struct mtd_info *mtd)  
81. {  
82.     DEBUGN("dev_ready\n");  
83.     return(NFSTAT & 0x01);  
84. }  
85.   
86. #ifdef CONFIG_S3C2410_NAND_HWECC  
87. void s3c2410_nand_enable_hwecc(struct mtd_info *mtd, int mode)  
88. {  
89.     struct s3c2410_nand *nand = s3c2410_get_base_nand();  
90.     debugX(1, "s3c2410_nand_enable_hwecc(%p, %d)\n", mtd, mode);  
91.     writel(readl(&nand->NFCONF) | S3C2410_NFCONF_INITECC, &nand->NFCONF);  
92. }  
93.   
94. static int s3c2410_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,  
95.                       u_char *ecc_code)  
96. {  
97.     struct s3c2410_nand *nand = s3c2410_get_base_nand();  
98.     ecc_code[0] = readb(&nand->NFECC);  
99.     ecc_code[1] = readb(&nand->NFECC + 1);  
100.     ecc_code[2] = readb(&nand->NFECC + 2);  
101.     debugX(1, "s3c2410_nand_calculate_hwecc(%p,): 0x%02x 0x%02x 0x%02x\n",  
102.            mtd , ecc_code[0], ecc_code[1], ecc_code[2]);  
103.   
104.     return 0;  
105. }  
106.   
107. static int s3c2410_nand_correct_data(struct mtd_info *mtd, u_char *dat,  
108.                      u_char *read_ecc, u_char *calc_ecc)  
109. {  
110.     if (read_ecc[0] == calc_ecc[0] &&  
111.         read_ecc[1] == calc_ecc[1] &&  
112.         read_ecc[2] == calc_ecc[2])  
113.         return 0;  
114.   
115.     printf("s3c2410_nand_correct_data: not implemented\n");  
116.     return -1;  
117. }  
118. #endif  
119.   
120. int board_nand_init(struct nand_chip *nand)  
121. {  
122.     u_int32_t cfg;  
123.     u_int8_t tacls, twrph0, twrph1;  
124.     struct s3c24x0_clock_power *clk_power = s3c24x0_get_base_clock_power();  
125.   
126.     DEBUGN("board_nand_init()\n");  
127.   
128.     writel(readl(&clk_power->CLKCON) | (1 << 4), &clk_power->CLKCON);  
129.   
130.     /* initialize hardware */  
131.     twrph0 = 4;  
132.     twrph1 =2;  
133.     tacls = 0;  
134.   
135.     cfg = ((tacls<<12)|(twrph0<<8)|(twrph1<<4));  
136.     NFCONF=cfg;  
137.     cfg = ((1<<6)|(1<<4)|(0<<1)|(1<<0));      
138.     NFCONT=cfg;  
139.     /* initialize nand_chip data structure */  
140.     nand->IO_ADDR_R = nand->IO_ADDR_W = (void *)0x4e000010;  
141.       
142.   
143.     /* read_buf and write_buf are default */  
144.     /* read_byte and write_byte are default */  
145.   
146.     /* hwcontrol always must be implemented */  
147.     nand->cmd_ctrl = s3c2440_hwcontrol;  
148.     nand->dev_ready = s3c2440_dev_ready;  
149.     nand->ecc.mode = NAND_ECC_SOFT;  
150.   
151.     DEBUGN("end of nand_init\n");  
152.   
153.     return 0;  
154. }