系统的启动流程

系统的启动流程
这里我们来讨论Uoot的启动流程，并将延伸至内核启动到start_kernel函数，我们主要讲start_kernel函数前系统都在做什么，系统是怎么样从开始运行，到解压内核，跳到内核运行，又怎么样从Uboot里将参数传到内核的。
Uboot的启动是从start.S文件开始的，系统一上电pc指针便指向这里开始程序的启动运行，在start.S文件中系统的工作主要有：
系统一上电便是reset异常，便跳到reset处进行处理，初始化Sdram,cache等，然后跳到board_init_f函数中运行。
Board_init_if（lib_mips/board.c）:
在此函数中对定时器进行初始化，环境变量初始化，初始化串口，然后根据Sdram进行计算（具体的计算过程看代码），计算出一个具体的地址，即SDRAM的高端地址，然后调用relocate_code函数，将Uboot程序Copy 到内存，copy完后即跳到in_ram（内存运行）中接着运行Uboot，最后调用board_init_r函数。
Relocate_code是一段汇编代码，位于start.S中，怎么实现copy就自已仔细看代码了啊，in_ram也在start.S中。
接下来我们来主要看board_init_r函数：
开始部分仍是对系统一些功能的初始化：
/* configure available FLASH banks */
size = flash_init(); 初始化flash
gpio_init(); //初始gpio
/** leave this here (after malloc(), environment and PCI are working) **/
/* Initialize devices */
devices_init ();//初始化外设
/* initialize the console (after the relocation and devices init) */
console_init_r ();初始化console
cy_nvram_init();
mac_init();
进行一些系统初配置初始化后，Uboot就便等待三秒，等待用户输入字符，以进行不同的操作，即当按下4时会进入命令处理模式，按下CTRL+ESC时会进入tftpd，可以进行文件的上传。我们这里只探讨正常启动不探讨tftpd下载和命令处理模式。
当我们启动时什么也不操作时，默认的启动类型为３，就会进入到这里：
if(BootType == '3') {
char *argv[3];
printf(" /n3: System Boot system code via Flash./n");
do_bootm(cmdtp, 0, 2, argv);　//从这里开始对内核进行解压，并跳到内核处运行。

/* below only when boot from flash fali*/
argv[2] = &file_name_space[0];
memset(file_name_space,0,ARGV_LEN);
eth_initialize(gd->bd);
do_tftpd(cmdtp, 0, 4, argv);　//启动tftpd。
}
如果kernel确实被写入了flash中，则do_bootm是不会返回的，则之后的do_tftpd就不会执行。当我们重新烧写Uboot后，必须重新烧写内核与文件系统，因此当重新烧写Uboot后，此时do_bootm就会出错，返回，则就开启了tftpd，进行下载模式。
接下来我们看看do_bootm函数，看它是怎么样解压内核，怎么样跳到内核执行的。
int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
………………………….
if (argc < 2) {
addr = load_addr;
} else {
addr = simple_strtoul(argv[1], NULL, 16); //我们传过来的参数为２，所以就从地址就是argv[1]，这个地址呢就是CFG_FLASH_BASE +0X40000,即0xbc440000,这里便是kernel的起始地址
}
memmove (&header, (char *)addr, sizeof(image_header_t));　//kernel启去始地址处我们在做code.bin时，在前面通过mkimage加了一个image_header的头，之后才加上code　pattern的。这里我们烧写的时侯去掉了code pattern，所以flash里开始处便是image_header头，这里就是将这个头读出来。

if (ntohl(hdr->ih_magic) != IH_MAGIC) {　//这里判断这个头正确不正确，通过一个IH_MAGIC来判断，每次重新烧写Uboot后，flash内核开始处，image_header就会被破坏，这个条件就不成立，于时就会在这里直接返回，之后就像上面所讲的进入了tftpd.
{
printf ("Bad Magic Number,%08X /n",ntohl(hdr->ih_magic));
SHOW_BOOT_PROGRESS (-1);
return 1;
}
}

data = (ulong)&header;
len = sizeof(image_header_t);

checksum = ntohl(hdr->ih_hcrc); //计算校验和是否正确
hdr->ih_hcrc = 0;

if (crc32 (0, (char *)data, len) != checksum) {
puts ("Bad Header Checksum/n");
SHOW_BOOT_PROGRESS (-2);
return 1;
}
SHOW_BOOT_PROGRESS (3);

/* for multi-file images we need the data part, too */
print_image_hdr ((image_header_t *)addr);　将image_header头的内容打印出来
Image Type: MIPS Linux Kernel Image (lzma compressed)
Data Size: 3174400 Bytes = 3 MB
Load Address: 8a00000
Entry Point: 881ee040
这个是我们当前的image_header头。
data = addr + sizeof(image_header_t);//去掉image_header头，这里便是kernel开始的部分了。
len = ntohl(hdr->ih_size);

#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
read_dataflash(data, len, (char *)CFG_LOAD_ADDR);
data = CFG_LOAD_ADDR;
}
#endif

if (verify) {
puts (" Verifying Checksum ... ");
if (crc32 (0, (char *)data, len) != ntohl(hdr->ih_dcrc)) {
printf ("Bad Data CRC/n");
//kaiker SHOW_BOOT_PROGRESS (-3);
return 1;
}
puts ("OK/n");
}
SHOW_BOOT_PROGRESS (4);

len_ptr = (ulong *)data;
………………………………………….
switch (hdr->ih_type) {　查看这部分的类型，目前为KERNEL，
case IH_TYPE_STANDALONE:
name = "Standalone Application";
/* A second argument overwrites the load address */
if (argc > 2) {
hdr->ih_load = simple_strtoul(argv[2], NULL, 16);
}
break;
case IH_TYPE_KERNEL:
name = "Kernel Image";　//执行这里。
break;
case IH_TYPE_MULTI:
name = "Multi-File Image";
len = ntohl(len_ptr[0]);
/* OS kernel is always the first image */
data += 8; /* kernel_len + terminator */
for (i=1; len_ptr[i]; ++i)
data += 4;
break;
default: printf ("Wrong Image Type for %s command/n", cmdtp->name);
SHOW_BOOT_PROGRESS (-5);
return 1;
}
SHOW_BOOT_PROGRESS (6);

/*
* We have reached the point of no return: we are going to
* overwrite all exception vector code, so we cannot easily
* recover from any failures any more...
*/

iflag = disable_interrupts();

switch (hdr->ih_comp) {　//判断压缩类型，刚才我们从image_header看出是lzma压缩的。
case IH_COMP_NONE:
if(ntohl(hdr->ih_load) == addr) {
printf (" XIP %s ... ", name);
} else {
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
size_t l = len;
void *to = (void *)ntohl(hdr->ih_load);
void *from = (void *)data;

printf (" Loading %s ... ", name);

while (l > 0) {
size_t tail = (l > CHUNKSZ) ? CHUNKSZ : l;
WATCHDOG_RESET();
memmove (to, from, tail);
to += tail;
from += tail;
l -= tail;
}
#else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
}
break;
case IH_COMP_GZIP:
#if 1
printf (" Uncompressing %s ... ", name);
if (gunzip ((void *)ntohl(hdr->ih_load), unc_len,
(uchar *)data + sizeof(struct trx_header), &len) != 0) {
puts ("GUNZIP ERROR - must RESET board to recover/n");
SHOW_BOOT_PROGRESS (-6);
do_reset (cmdtp, flag, argc, argv);
}
#endif
break;
#ifdef CONFIG_BZIP2
case IH_COMP_BZIP2:
printf (" Uncompressing %s ... ", name);
/*
* If we've got less than 4 MB of malloc() space,
* use slower decompression algorithm which requires
* at most 2300 KB of memory.
*/
i = BZ2_bzBuffToBuffDecompress ((char*)ntohl(hdr->ih_load),
&unc_len, (char *)data, len,
CFG_MALLOC_LEN < (4096 * 1024), 0);
if (i != BZ_OK) {
printf ("BUNZIP2 ERROR %d - must RESET board to recover/n", i);
SHOW_BOOT_PROGRESS (-6);
udelay(100000);
do_reset (cmdtp, flag, argc, argv);
}
break;
#endif /* CONFIG_BZIP2 */
#ifdef CONFIG_LZMA　//所以就跳到这里来了，
case IH_COMP_LZMA:
printf (" Uncompressing %s ... ", name);

#ifdef CONFIG_UNCOMPRESS_TIME
tBUncompress = get_ticks();
#endif
unsigned int destLen = 0;
接来来开始解压，解压目的地址hdr->ih_load，我们从打印的image_header看出，是0x8a000000.，所以解压到这里。
i = lzmaBuffToBuffDecompress ((char*)ntohl(hdr->ih_load),
&destLen, (char *)data + sizeof(struct trx_header), len);
if (i != LZMA_RESULT_OK) {
printf ("LZMA ERROR %d - must RESET board to recover/n", i);
return 1;
//SHOW_BOOT_PROGRESS (-6);
//udelay(100000);
//do_reset (cmdtp, flag, argc, argv);
}
#endif /* CONFIG_LZMA */
default:
if (iflag)
enable_interrupts();
printf ("Unimplemented compression type %d/n", hdr->ih_comp);
SHOW_BOOT_PROGRESS (-7);
return 1;
}
………………………………….
switch (hdr->ih_os) { //这里我们是linux内核，所以要调用do_bootm_linux函数。
default: /* handled by (original) Linux case */
case IH_OS_LINUX:
#ifdef CONFIG_SILENT_CONSOLE
fixup_silent_linux();
#endif
do_bootm_linux (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
…………………………………………………………………………………..
}
return 1;
}
接下来我们看看do_bootm_linux函数，现在以经解压完了，所以这里我们只关注它是怎么跳转到内核开始运行的。
do_bootm_linux (cmd_tbl_t *cmdtp, int flag,
int argc, char *argv[],
ulong addr,
ulong *len_ptr,
int verify)
{
…………………………………………………..
kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong))hdr->ih_ep;//image_header，ih_ep，对于当前内核，我们可以从刚才打印imager_header参数时看出，为0x881ee040,这个地址是什么呢，它其时就是head.S,kernel_entry的地址，
……………………………………………….
(*kernel) (kbd, initrd_start, initrd_end, cmd_start, cmd_end);　//这里就是跳到kernel的地方，即跳到kernel_entry处开始内核的运行了。之后就便是开始从head.S中的kernel_entry开始执行了。从而完成从Uboot到内核的交接。
}
接下来我们进入内核看看：
* Kernel entry point
*/
NESTED(kernel_entry, 16, sp)　//kernel进入点
.set push
/*
* For the moment disable interrupts and mark the kernel mode.
* A full initialization of the CPU's status register is done
* later in per_cpu_trap_init().
*/
mfc0 t0, CP0_STATUS
or t0, ST0_CU0|0x1f
xor t0, 0x1f
mtc0 t0, CP0_STATUS

.set noreorder
sll zero,3 # ehb
.set reorder

/*
* The firmware/bootloader passes argc/argp/envp
* to us as arguments. But clear bss first because
* the romvec and other important info is stored there
* by prom_init().
*/
la t0, _edata
sw zero, (t0)
la t1, (_end - 4)
1:
addiu t0, 4
sw zero, (t0)
bne t0, t1, 1b

/*
* Stack for kernel and init, current variable
*/
la $28, init_task_union
addiu t0, $28, KERNEL_STACK_SIZE-32
subu sp, t0, 4*SZREG
sw t0, kernelsp

jal init_arch //跳到init_arch函数，从这里跳到Ｃ代码执行。
.set pop
END(kernel_entry)
Init_arch函数：

asmlinkage void __init
init_arch(int argc, char **argv, char **envp, int *prom_vec)
{
/* Determine which MIPS variant we are running on. */
cpu_probe();　//CPU探测，读出CPU　ID

prom_init(argc, argv, envp, prom_vec);

cpu_report();//打印ＣＰＵ信息

/*
* Determine the mmu/cache attached to this machine,
* then flush the tlb and caches. On the r4xx0
* variants this also sets CP0_WIRED to zero.
*/
load_mmu();//

start_kernel();
}
int __init prom_init()
{

/* change parameter by bobtseng, 2006.1.3. */
mips_machgroup = MACH_GROUP_RT2880;

set_io_port_base(KSEG1);

prom_init_cmdline(); //初始化启动参数，将启动参数分解并存入argc数组里
prom_init_sysclk();　//初始化ＣＰＵ频率
prom_init_serial_port(); /* Needed for Serial Console */　//初始化串口参数
// prom_init_mac(); // remove for test, bobtseng 2006.1.3.
prom_setup_printf(prom_get_ttysnum());　//可能有两个串口，选择哪一个
#if defined(CONFIG_RT2880_FPGA)
prom_printf("/nTHIS IS FPGA/n");
#elif defined(CONFIG_RT2880_ASIC)
prom_printf("/nTHIS IS ASIC/n");
#else
#error Please Choice Chip Type
#endif

prom_meminit();　//初始化SDRAM，取出base地址和size大小，为mmu做准备
return 0;
}
以上便是从Uboot的启动到内核start_kernel的运行过程，start_kernel之后便是跟内核原理紧密相关的启动过程，在这里就不介绍了，有兴趣的同事可以慢慢研究。这里仍有两个问题。
一个是我们正常的桌面linux（如Redhat），在系统启动的时侯，参数都是通过lilo或grub启动程序传给内核的，即同理，启动参数也可以从Uboot传到内核，问题就是参数是怎么样传递的呢？
一个是在init_arch函数里，调用了prom_init函数，调用prom_init时带了四个能数，但是prom_init原形确不带参数，这个又是为什么呢？接下来我们就讲讲这两个问题。
a、 Uboot跳到内核是通过kernel­_entry的地址跳过来的，kernel_entry是汇编语言，Uboot在调用时确是Ｃ语言的实现过程，所以一般这里就不容易看出参数的传递规则了。
由于Ｃ在编译时还是要通过汇编这一关，因此我们也就只关注汇编语言中函数参数是怎么传递的，也就明白了这个问题。
通常每种架构（intel, mips,arm）的CPU，都有各自的汇编指令，都有各自独特的寄存器，同时也都有很多的共性，原理上也都大同小异。我们通常编程都是用的高级语言，高级语言中都是有函数调用的，函数往往是带参数的，高级语言在编译成汇编时，参数是怎么样表示的。因此,针对汇编语言，只有指令，与操作数，操作数就只有寄存器与立即数。因此针对每种架构的CPU，专门有预留的寄存器用来传递函数参数的，在MIPS架构中，a0-a3就是这样的寄存器。
Uboot在解压完内核后，通过一个地址调用函数进入内核中运行，并且携带启动参数，由于进入内核是汇编语言，所以这此参数放在a0－a3的寄存器中（这个是由ＭＩＰＳ架构决定的，a0-a3专门存放子程序的参数）.
b、 这个问题跟函数名前的__init 有关系，int __init prom_init()，

#define __init __attribute__ ((__section__ (".text.init")))

这个宏的定义将这段代码放在.text.init这里，通过__attribute__展开，在这里attribute只是gcc的一个属性，针对这个属性gcc编译时对此函数不做参数方面的检查(检查不是很严格)。所以编译就没问题。gcc由于attribute，所以编译时不检查函数参数，我们在调用子函数时可以带参数，也可以不带参数，也可以少带参数等，这个根据需要而定。我想应该是这样的。
链接时将此函数放入.text.init段里，之后运行时直接根据prom_init进行跳转运行。