分类: 嵌入式
2015-11-08 16:05:59
u-boot-1.1.6源码分析
15年11月1日15:22:59
想要分析一个大的程序是从哪一个文件开始执行的,首先是分析它的Makefile,当然也可以采取一个取巧的办法,将编译过的uboot.bin文件删除,然后从新make,从它的最后的输出信息里面找到 arm-linux-ld链接命令,如下所示:
cd /home/ybx/u-boot-1.1.6 && arm-linux-ld -Bstatic -T /home/ybx/u-boot-1.1.6/board/100ask24x0/u-boot.lds -Ttext 0x33F80000 $UNDEF_SYM cpu/arm920t/start.o .......
这样就可以轻松找到第一个执行文件,当然,对于uboot来说,没啥必要~~~
对于以下内容,所有的源代码都有灰色阴影,我所添加的注释没有阴影,对于2410里面配置的宏用红色字体标出,对于代码和注释,始终坚持代码在前,注释在后的潜规则(~.~!)严格执行~~~
(1)那么就来分析这个文件:/cpu/arm920t/start.S:
#include
#include
.globl _start
_start: b reset
ldr pc, _undefined_instruction
ldr pc, _software_interrupt
ldr pc, _prefetch_abort
ldr pc, _data_abort
ldr pc, _not_used
ldr pc, _irq
ldr pc, _fiq
_undefined_instruction: .word undefined_instruction
_software_interrupt: .word software_interrupt
_prefetch_abort: .word prefetch_abort
_data_abort: .word data_abort
_not_used: .word not_used
_irq: .word irq
_fiq: .word fiq
.balignl 16,0xdeadbeef
/*
*************************************************************************
*
* Startup Code (reset vector)
*
* do important init only if we don't start from memory!
* relocate armboot to ram
* setup stack
* jump to second stage
*
*************************************************************************
*/
_TEXT_BASE:
.word TEXT_BASE
.globl _armboot_start
_armboot_start:
.word _start
/*
* These are defined in the board-specific linker script.
*/
.globl _bss_start
_bss_start:
.word __bss_start
.globl _bss_end
_bss_end:
.word _end
/* 这一段代码是程序的起始阶段,设置程序的中断向量表。关于这个中断向量表,我有一篇博客里面仔细分析了。一般的uboot都会将中断关掉的。那我们就直接跳到reset这个标号那里继续执行。 */
(2)这个reset是start.S中的一个标号,程序继续在/cpu/arm920t/start.S中执行:
/*
* the actual reset code
*/
reset:
/*
* set the cpu to SVC32 mode
*/
mrs r0,cpsr
bic r0,r0,#0x1f
orr r0,r0,#0xd3
msr cpsr,r0
/* 将cpu设置成管理模式,至于为什么设置成管理模式,可以参见《Uboot中start.S源码的指令级的详尽解析》 那篇文章。 */
/* turn off the watchdog */
#if defined(CONFIG_S3C2400)
# define pWTCON 0x15300000
# define INTMSK 0x14400008 /* Interupt-Controller base addresses */
# define CLKDIVN 0x14800014 /* clock divisor register */
#elif defined(CONFIG_S3C2410)
# define pWTCON 0x53000000
# define INTMSK 0x4A000008 /* Interupt-Controller base addresses */
# define INTSUBMSK 0x4A00001C
# define CLKDIVN 0x4C000014 /* clock divisor register */
#endif
/* 根据不同的宏来分别设置寄存器的地址,因为uboot兼容很多单板,这个技巧很常用。 */
#if defined(CONFIG_S3C2400) || defined(CONFIG_S3C2410)
ldr r0, =pWTCON
mov r1, #0x0
str r1, [r0]
/* 关闭看门狗,往寄存器里面写0即可。 */
/*
* mask all IRQs by setting all bits in the INTMR - default
*/
mov r1, #0xffffffff
ldr r0, =INTMSK
str r1, [r0]
# if defined(CONFIG_S3C2410)
ldr r1, =0x3ff
ldr r0, =INTSUBMSK
str r1, [r0]
# endif
/* 关闭所有中断,对于S3C2410来说,还把子中断寄存器INTSUBMSK关掉了,往寄存器里面写1即可,这个在用户手册里面有说明。 */
/* FCLK:HCLK:PCLK = 1:2:4 */
/* default FCLK is 120 MHz ! */
ldr r0, =CLKDIVN
mov r1, #3
str r1, [r0]
#endif /* CONFIG_S3C2400 || CONFIG_S3C2410 */
/* 设置分频系数 */
/*
* we do sys-critical inits only at reboot,
* not when booting from ram!
*/
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
bl cpu_init_crit
#endif
/* 这段代码很有意思,C语言的关键字是#ifndef,意思是如果没有定义这个宏的话,那么就执行下面的语句,要仔细看清楚了,不能与#ifdef相混淆。很显然,2410中没有定义这个宏,那么就跳转到cpu_init_crit中去执行,在这里使用的是bl跳转指令,当程序执行完cpu_init_crit的时候,再返回到这里继续往下执行。先标记好这里,一会需要返回到这。 */
(3)cpu_init_crit也是start.S中的一个标号,以下代码仍在/cpu/arm920t/start.S中:
#ifndef CONFIG_SKIP_LOWLEVEL_INIT
cpu_init_crit:
/*
* flush v4 I/D caches
*/
mov r0, #0
mcr p15, 0, r0, c7, c7, 0 /* flush v3/v4 cache */
mcr p15, 0, r0, c8, c7, 0 /* flush v4 TLB */
/* 关掉I/D caches */
/*
* disable MMU stuff and caches
*/
mrc p15, 0, r0, c1, c0, 0
bic r0, r0, #0x00002300 @ clear bits 13, 9:8 (--V- --RS)
bic r0, r0, #0x00000087 @ clear bits 7, 2:0 (B--- -CAM)
orr r0, r0, #0x00000002 @ set bit 2 (A) Align
orr r0, r0, #0x00001000 @ set bit 12 (I) I-Cache
mcr p15, 0, r0, c1, c0, 0
/* 关掉MMU */
/*
* before relocating, we have to setup RAM timing
* because memory timing is board-dependend, you will
* find a lowlevel_init.S in your board directory.
*/
mov ip, lr
bl lowlevel_init
mov lr, ip
mov pc, lr
#endif /* CONFIG_SKIP_LOWLEVEL_INIT */
/* 这里又有一个lowlevel_init函数,跳到这个函数中去执行。可以仔细读读这个英文注释:在重定位代码前,需要先设置RAM的时钟,因为RAM时序是依赖于单板的,你能够在你的单板目录下找到一个 lowlevel_init.S文件。所以我们跳到SMDK2410的单板目录下的lowlevel_init.S文件。同时注意这个函数也是bl跳转的,执行完以后还需要跳转回来。 */
(4)跳到/board/smdk2410/lowlevel_init.S中:
_TEXT_BASE:
.word TEXT_BASE
.globl lowlevel_init
lowlevel_init:
/* memory control configuration */
/* make r0 relative the current location so that it */
/* reads SMRDATA out of FLASH rather than memory ! */
ldr r0, =SMRDATA
ldr r1, _TEXT_BASE
sub r0, r0, r1
ldr r1, =BWSCON /* Bus Width Status Controller */
add r2, r0, #13*4
0:
ldr r3, [r0], #4
str r3, [r1], #4
cmp r2, r0
bne 0b
/* everything is fine now */
mov pc, lr
.ltorg
/* the literal pools origin */
SMRDATA:
.word (0+(B1_BWSCON<<4)+(B2_BWSCON<<8)+(B3_BWSCON<<12)+(B4_BWSCON<<16)+ (B5_BWSCON<<20)+(B6_BWSCON<<24)+(B7_BWSCON<<28))
.word ((B0_Tacs<<13)+(B0_Tcos<<11)+(B0_Tacc<<8)+(B0_Tcoh<<6)+(B0_Tah<<4)+ (B0_Tacp<<2)+(B0_PMC))
.word ((B1_Tacs<<13)+(B1_Tcos<<11)+(B1_Tacc<<8)+(B1_Tcoh<<6)+(B1_Tah<<4)+ (B1_Tacp<<2)+(B1_PMC))
.word ((B2_Tacs<<13)+(B2_Tcos<<11)+(B2_Tacc<<8)+(B2_Tcoh<<6)+(B2_Tah<<4)+ (B2_Tacp<<2)+(B2_PMC))
.word ((B3_Tacs<<13)+(B3_Tcos<<11)+(B3_Tacc<<8)+(B3_Tcoh<<6)+(B3_Tah<<4)+ (B3_Tacp<<2)+(B3_PMC))
.word ((B4_Tacs<<13)+(B4_Tcos<<11)+(B4_Tacc<<8)+(B4_Tcoh<<6)+(B4_Tah<<4)+ (B4_Tacp<<2)+(B4_PMC))
.word ((B5_Tacs<<13)+(B5_Tcos<<11)+(B5_Tacc<<8)+(B5_Tcoh<<6)+(B5_Tah<<4)+ (B5_Tacp<<2)+(B5_PMC))
.word ((B6_MT<<15)+(B6_Trcd<<2)+(B6_SCAN))
.word ((B7_MT<<15)+(B7_Trcd<<2)+(B7_SCAN))
.word ((REFEN<<23)+(TREFMD<<22)+(Trp<<20)+(Trc<<18)+(Tchr<<16)+REFCNT)
.word 0x32
.word 0x30
.word 0x30
/* 进行SDRAM的初始化,关于下面这一段汇编,
ldr r0, =SMRDATA
ldr r1, _TEXT_BASE
sub r0, r0, r1
ldr r1, =BWSCON /* Bus Width Status Controller */
add r2, r0, #13*4
为什么要写的这么奇怪呢?这就涉及到代码重定位的知识了。在重定位代码之前,SDRAM还没有初始化,只能使用相对地址来执行程序,同样必须使用相对跳转指令。我们的目的是将SMRDATA标号处的值一一存在以BWSCON开始的几个存储控制寄存器中,那么怎么定位SMRDATA的位置呢?先在前面用
_TEXT_BASE:
.word TEXT_BASE
来保存一个地址值,然后计算出SMRDATA与_TEXT_BASE的相对偏移量,并保存在r0中,这时候r0中的值就是SMRDATA的地址值,然后将SMRDATA开始的各个值保存在 BWSCON开始的寄存器中。用的方法是汇编中经常用的循环保存值的方法。一共13个寄存器,每个寄存器占4个字节。*/
(5)执行完lowlevel_init后,跳回到cpu_init_crit执行,从cpu_init_crit返回到/cpu/arm920t/start.S中继续执行:
#ifndef CONFIG_SKIP_RELOCATE_UBOOT
relocate: /* relocate U-Boot to RAM */
adr r0, _start /* r0 <- current position of code */
ldr r1, _TEXT_BASE /* test if we run from flash or RAM */
cmp r0, r1 /* don't reloc during debug */
beq stack_setup
/* 这一段程序的目的是判断 _start 和 _TEXT_BASE 是否相同,如果程序开始执行的地方就位于程序的链接地址的话,就不用重定位了。如果是nor启动,_start即为代码的最开始,相对的0的位置;如果重新relocate代码之后,_start就是在/board/smdk2410/config.mk中定义的TEXT_BASE = 0x33F80000位置,即_start = TEXT_BASE = 0x33F80000,这样的话就不用重定位代码了。 */
ldr r2, _armboot_start
ldr r3, _bss_start
sub r2, r3, r2 /* r2 <- size of armboot */
add r2, r0, r2 /* r2 <- source end address */
/* 能执行到这,就说明_start 和 _TEXT_BASE 是不相同的。重定位代码就是把代码从源地址拷贝到目的地址,拷贝多大的问题。源就是r0中的值,为_start,目的就是r1中的值,为_TEXT_BASE,程序拷贝多大呢?从链接脚本里面可以看出来,用(_bss_start - _armboot_start)即为程序的大小。 */
copy_loop:
ldmia r0!, {r3-r10} /* copy from source address [r0] */
stmia r1!, {r3-r10} /* copy to target address [r1] */
cmp r0, r2 /* until source end addreee [r2] */
ble copy_loop
#endif /* CONFIG_SKIP_RELOCATE_UBOOT */
/* 拷贝代码。 */
/* Set up the stack */
stack_setup:
ldr r0, _TEXT_BASE /* upper 128 KiB: relocated uboot */
sub r0, r0, #CFG_MALLOC_LEN /* malloc area */
sub r0, r0, #CFG_GBL_DATA_SIZE /* bdinfo */
#ifdef CONFIG_USE_IRQ
sub r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ)
#endif
sub sp, r0, #12 /* leave 3 words for abort-stack */
/* 设置栈,在经过上面的重定位代码以后, r0 = TEXT_BASE = 0x33F80000,去除分给malloc堆的空间以后,再取出一部分空间给bdinfo结构体,再留出12字节给终止异常的空间,然后将这个值赋给sp,即设置好了栈。 */
clear_bss:
ldr r0, _bss_start /* find start of bss segment */
ldr r1, _bss_end /* stop here */
mov r2, #0x00000000 /* clear */
clbss_l:str r2, [r0] /* clear loop... */
add r0, r0, #4
cmp r0, r1
ble clbss_l
/* 清BSS段,BSS段的大小为(_bss_end - _bss_start),将这个空间都清为0。 */
ldr pc, _start_armboot
_start_armboot: .word start_armboot
/* 将_start_armboot的值赋给pc,即调用start_armboot函数,即跳到uboot的第二阶段。 */
(6)跳转到start_armboot函数中,它位于lib_arm/board.c 中:
void start_armboot (void)
{
init_fnc_t **init_fnc_ptr;
char *s;
#ifndef CFG_NO_FLASH
ulong size;
#endif
/* 在这个文件lib_arm/board.c的前面,有init_fnc_t的定义:
typedef int (init_fnc_t) (void);
其中 init_fnc_t 如下,它是一个函数类型,该类型的函数参数都为空(void),且都返回整型值(int)。
init_fnc_t *init_sequence[] = {
cpu_init, /* basic cpu dependent setup */
board_init, /* basic board dependent setup */
interrupt_init, /* set up exceptions */
env_init, /* initialize environment */
init_baudrate, /* initialze baudrate settings */
serial_init, /* serial communications setup */
console_init_f, /* stage 1 init of console */
display_banner, /* say that we are here */
dram_init, /* configure available RAM banks */
display_dram_config,
NULL,
};
init_fnc_t **init_fnc_ptr;
那么这里就定义了变量init_fnc_ptr,它是一个指针变量,其中存的是另一个变量B的地址,而变量B也是一个指针变量,其中存的是init_fnc_t类型的函数的地址。*/
/* Pointer is writable since we allocated a register for it */
gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN – sizeof(gd_t));
/* 这个gd是啥?在本文件前面可以看到一个这样的声明:
DECLARE_GLOBAL_DATA_PTR;
这个宏在/include/asm-arm/global_data.h中是这样定义的:
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("r8")
即这个gd就是 r8寄存器的值,每次调用gd都需要重新从r8寄存器中取值。至于为啥这样,我以后明白了再修改这。。。
_armboot_start 定义代码段的起始地址,定义在start.S中
_armboot_start:
.word
_start
可见其中保存的是第一条指令_start的地址。编译的时候指定了TEXT_BASE为0x33F80000,所以
_armboot_start中的值也为0x33F80000。
CFG_MALLOC_LEN 也在/include/configs/smdk2410.h中定义了,如下所示:
#define
CFG_MALLOC_LEN (CONFIG_ENV_SIZE + 128*1024)
#define
CONFIG_ENV_SIZE 0x10000 /* Total Size of Environment Sector
*/
所以==>
CFG_MALLOC_LEN = 0x10000 + 128*1024 = 0x10000 + 0x20000 =
0x30000,即192k。
sizeof(gd_t)
= 9 * 4 = 36 = 0x24 (这里没有VDF和LCD)。 */
/* compiler optimization barrier needed for GCC >= 3.4 */
__asm__ __volatile__("": : :"memory");
/* __asm__
__volatile__("": : :"memory"); 是内嵌汇编的知识,
__asm__用于指示编译器在此插入汇编语句
__volatile__用于告诉编译器,严禁将此处的汇编语句与其它的语句重组合优化。即:原原本本按原来的
样子处理这这里的汇编。
memory强制gcc编译器假设RAM所有内存单元均被汇编指令修改,这样cpu中的registers和cache中已缓存的内存单元中的数据将作废。cpu将不得不在需要的时候重新读取内存中的数据。这就阻止了cpu又将registers,cache中的数据用于去优化指令,而避免去访问内存。
""::: 表示这是个空指令。barrier()不用在此插入一条串行化汇编指令。 */
memset ((void*)gd, 0, sizeof (gd_t));
gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));
memset (gd->bd, 0, sizeof (bd_t));
/* 上面这些代码就是定义gd 和 bd的位置,并将这两个结构体先清零,大致的布局如下
+------------+ ->
0x34000000 sp
| 512k | -> 这个位置为了放u-boot
+------------+ ->
0x33f80000 _armboot_start
| 192k | -> CFG_MALLOC_LEN =
192k
+------------+ -> 0x33f50000
| 24k | ->
sizeof(gd_t) = 0x24,为uboot的配置信息
+------------+
<------- gd就指向这里了。
|
| -> sizeof(bd_t), 板级相关信息
+------------+
<------- gd->bd 就指向这里了。
|
|
+------------+
*/
gd_t结构体在include/asm-arm/global_data.h中定义,如下所示:
typedef struct global_data {
bd_t *bd;
unsigned long flags;
unsigned long baudrate;
unsigned long have_console; /* serial_init() was called */
unsigned long reloc_off; /* Relocation Offset */
unsigned long env_addr; /* Address of Environment struct */
unsigned long env_valid; /* Checksum of Environment valid? */
unsigned long fb_base; /* base address of frame buffer */
void **jt; /* jump table */
} gd_t;
在这个结构体里面保存了uboot的配置信息,如波特率,flags等信息。
bd_t结构体在include/asm-arm/u-boot.h中定义,如下所示:
typedef struct bd_info {
int bi_baudrate; /* serial console baudrate */
unsigned long bi_ip_addr; /* IP Address */
unsigned char bi_enetaddr[6]; /* Ethernet adress */
struct environment_s *bi_env;
ulong bi_arch_number; /* unique id for this board */
ulong bi_boot_params; /* where this board expects params */
struct /* RAM configuration */
{
ulong start;
ulong size;
} bi_dram[CONFIG_NR_DRAM_BANKS];
} bd_t;
这个结构体保存了一些板子的信息,如IP地址,机器ID等信息。
这两个结构体贯穿了uboot的整体,很重要。
monitor_flash_len = _bss_start - _armboot_start;
/* 计算代码段的长度,根据链接脚本里面的计算的,bss段开始的地址减去程序开始的地址,就是代码段的长度。 */
for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
if ((*init_fnc_ptr)() != 0) {
hang ();
}
}
/* 在上面说了,这个变量init_fnc_ptr,它是一个指针变量,其中存的是另一个变量B的地址,而变量B也是一个指针变量,其中存的是init_fnc_t类型的函数的地址,所以这个for循环可以表示为遍历init_sequence 这个数组里面所有的函数。那么就跳到这个数组里面,分析分析每个函数都干了什么事情。关于init_sequence这个函数数组已经在前面写出来了,在这就不阐述了。 */
<1> 首先是 cpu_init, /* basic cpu dependent setup */
这个函数在/cpu/arm920t/cpu.c里面,代码如下:
int cpu_init (void)
{
/*
* setup up stacks if necessary
*/
#ifdef CONFIG_USE_IRQ
IRQ_STACK_START = _armboot_start - CFG_MALLOC_LEN - CFG_GBL_DATA_SIZE - 4;
FIQ_STACK_START = IRQ_STACK_START - CONFIG_STACKSIZE_IRQ;
#endif
return 0;
}
并没有定义CONFIG_USE_IRQ这个宏,所以对于我们来说,什么都没做。
在start.S中,对于这个宏有定义,如下所示:
.globl IRQ_STACK_START
IRQ_STACK_START:
.word 0x0badc0de
这个函数的目的就是在uboot使用中断的情况下,设置栈的位置等信息。
<2> board_init, /* basic board dependent setup */
这个函数在board/smdk2410/smdk2410.c中定义,代码如下:
int board_init (void)
{
S3C24X0_CLOCK_POWER * const clk_power = S3C24X0_GetBase_CLOCK_POWER();
S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
/* to reduce PLL lock time, adjust the LOCKTIME register */
clk_power->LOCKTIME = 0xFFFFFF;
/* configure MPLL */
clk_power->MPLLCON = ((M_MDIV << 12) + (M_PDIV << 4) + M_SDIV);
/* some delay between MPLL and UPLL */
delay (4000);
/* configure UPLL */
clk_power->UPLLCON = ((U_M_MDIV << 12) + (U_M_PDIV << 4) + U_M_SDIV);
/* some delay between MPLL and UPLL */
delay (8000);
/* set up the I/O ports */
gpio->GPACON = 0x007FFFFF;
gpio->GPBCON = 0x00044555;
gpio->GPBUP = 0x000007FF;
gpio->GPCCON = 0xAAAAAAAA;
gpio->GPCUP = 0x0000FFFF;
gpio->GPDCON = 0xAAAAAAAA;
gpio->GPDUP = 0x0000FFFF;
gpio->GPECON = 0xAAAAAAAA;
gpio->GPEUP = 0x0000FFFF;
gpio->GPFCON = 0x000055AA;
gpio->GPFUP = 0x000000FF;
gpio->GPGCON = 0xFF95FFBA;
gpio->GPGUP = 0x0000FFFF;
gpio->GPHCON = 0x002AFAAA;
gpio->GPHUP = 0x000007FF;
/* arch number of SMDK2410-Board */
gd->bd->bi_arch_number = MACH_TYPE_SMDK2410;
/* adress of boot parameters */
gd->bd->bi_boot_params = 0x30000100;
icache_enable();
dcache_enable();
return 0;
}
上面代码中S3C24X0_CLOCK_POWER * const clk_power = S3C24X0_GetBase_CLOCK_POWER();
这是uboot对寄存器访问的方式,对于底层的寄存器访问,uboot都采取了这种方式,好好体会:
1> 首先定义了S3C24X0_CLOCK_POWER 结构,在include/s3c24x0.h中:
typedef struct {
S3C24X0_REG32 LOCKTIME;
S3C24X0_REG32 MPLLCON;
S3C24X0_REG32 UPLLCON;
S3C24X0_REG32 CLKCON;
S3C24X0_REG32 CLKSLOW;
S3C24X0_REG32 CLKDIVN;
} /*__attribute__((__packed__))*/ S3C24X0_CLOCK_POWER;
2> 然后S3C24X0_GetBase_CLOCK_POWER()的定义在include/s3c2410.h中,如下所示,通过这个方法获取寄存器的基地址:
static inline S3C24X0_CLOCK_POWER * const S3C24X0_GetBase_CLOCK_POWER(void)
{
return (S3C24X0_CLOCK_POWER * const)S3C24X0_CLOCK_POWER_BASE;
}
3> S3C24X0_CLOCK_POWER_BASE的宏定义也在include/s3c2410.h中,为CLOCK首个寄存器的基地址:
#define S3C24X0_CLOCK_POWER_BASE 0x4C000000
4> 这样看也就好理解了,对于底层的每一个模块如clock模块,gpio模块,nand模块,uart模块等,uboot中都定义了相关的结构体,如 S3C24X0_CLOCK_POWER,S3C24X0_GPIO,S3C2410_NAND,S3C24X0_UART等,然后用上面的方法调用相应模块,
如S3C24X0_CLOCK_POWER * const clk_power = S3C24X0_GetBase_CLOCK_POWER();
再从相应的单板中取出相应的地址值,这种内核中常用的面向对象的思想。。。。。。
5> 这个函数中对于GPIO也采用了上述方法,我在这列举如下,自行体会吧:
其中 S3C24X0_GPIO这个结构体过于庞大,我就没有列举,去include/s3c24x0.h中查看。
static inline S3C24X0_GPIO * const S3C24X0_GetBase_GPIO(void)
{
return (S3C24X0_GPIO * const)S3C24X0_GPIO_BASE;
}
#define S3C24X0_GPIO_BASE 0x56000000
总结:这个函数依次完成了:设置LOCKTIME,MPLLCON,UPLLCON,GPIO管脚,并在最后通过
gd->bd->bi_arch_number = MACH_TYPE_SMDK2410;
gd->bd->bi_boot_params = 0x30000100;
设置了机器ID和uboot向内核传递参数(tag)的地址信息,这两个信息用于启动内核的时候,传给theKernel函数:
theKernel (0, machid, bd->bi_boot_params)。
然后激活了icache和dcache,这两个函数就不列举了。
<3> interrupt_init, /* set up exceptions */
int interrupt_init (void)
{
S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS();
/* use PWM Timer 4 because it has no output */
/* prescaler for Timer 4 is 16 */
timers->TCFG0 = 0x0f00;
if (timer_load_val == 0)
{
/*
* for 10 ms clock period @ PCLK with 4 bit divider = 1/2
* (default) and prescaler = 16. Should be 10390
* @33.25MHz and 15625 @ 50 MHz
*/
timer_load_val = get_PCLK()/(2 * 16 * 100);
}
/* load value for 10 ms timeout */
lastdec = timers->TCNTB4 = timer_load_val;
/* auto load, manual update of Timer 4 */
timers->TCON = (timers->TCON & ~0x0700000) | 0x600000;
/* auto load, start Timer 4 */
timers->TCON = (timers->TCON & ~0x0700000) | 0x500000;
timestamp = 0;
return (0);
}
这个函数实际上是设置timer定时器,2410总共有5个定时器,timer0~timer4,这里使用timer
4,原因解释的很清楚了, because
it has no
output。timer0~timer4有脉冲宽度调制(PWM)功能,因此这4个定时器也被称为PWM定时器。timer4是一个内部定时器,无外部输出引脚。
那么看上面的代码:
1>
prescaler1
timers->TCFG0 = 0x0f00;
这里要使用timer4,所以设置其[15:8]为0f,即prescaler1
= 16
2> 定时器初值计算
timer_load_val
= get_PCLK()/(2 * 16 * 100);
get_PCLK()位于cpu/arm920t/s3c24x0/speed.c 中,取得pclk的过程如下
FCLK
=> HCLK = FCLK / 2 => PCLK = HCLK /
2
即先通过MPLLCON的值计算得出FCLK,然后根据CLKDIVN的分频率比得出HCLK 和 PCLK。
要做一个10ms的定时器,所以这里计算初值。上面prescaler1
= 16, 且此处没有设置TCFG1,所以TCFG1为默认值0, 则divider选择了1/2;
1s = 10ms * 100;
于是,需要的三个参数全都出来了
分频后频率为 (clk
/(2 * 16)),即每秒要做(clk/(2
* 16))次减计数,那么10ms就要做 clk
/ (2 * 16 * 100)次减计数。
3>
TCNTB4
timers->TCNTB4
= timer_load_val 将值记录于TCNTB4中。在 auto
reload 模式时,在减计数一次完成之后,会自动将 TCNTB4 的值赋给 TCNT4
4>
TCON
最后
设置 TCON 的bit[22:20]
timers->TCON = (timers->TCON & ~0x0700000) | 0x600000;
=> bit[22:20] = 110
即选择 auto
reload mode, update TCNTB4。
timers->TCON
= (timers->TCON & ~0x0700000) | 0x500000; => bit[22:20] =
101
即 auto
reload mode, start for timer4 此时,真正开始定时器4。
<4> env_init, /* initialize environment */
env_init函数在很多文件里面都有函数的定义,比如在env_dataflash.c, env_flash.c, env_nand.c等等,那么这个环境变量到底存在哪呢?随便打开一个文件,比如说env_nand.c中,查看的时候发现在这个文件的头部:#if defined(CFG_ENV_IS_IN_NAND),发现这是一个宏开关,肯定在2410的配置文件中定义了这些环境变量放在哪,于是又查看了env_flash.c文件,发现
#if defined(CFG_ENV_IS_IN_FLASH),追踪各个宏定义,发现在/include/config/smdk2410.h中定义了这些宏开关,发现在2410的默认代码中,环境变量是放在flash中的。于是下面的这个函数就是common/env_flash.c中的函数:
(但是发现env_flash.c中有两个env_init函数啊。。。。真是日了dog了。。。)
分析代码,发现是这样的:
#ifdef CFG_ENV_ADDR_REDUND
int env_init(void)
{
...
}
else
{
int env_init(void)
{
...
}
}
而CFG_ENV_ADDR_REDUND是在/include/environment.h中定义的,所以就用第一个env_init函数吧,因为还不知道
/include/environment.h这个头文件是怎么使用的,所以暂且这样分析。。。
int env_init(void)
{
int crc1_ok = 0, crc2_ok = 0;
uchar flag1 = flash_addr->flags;
uchar flag2 = flash_addr_new->flags;
ulong addr_default = (ulong)&default_environment[0];
ulong addr1 = (ulong)&(flash_addr->data);
ulong addr2 = (ulong)&(flash_addr_new->data);
crc1_ok = (crc32(0, flash_addr->data, ENV_SIZE) == flash_addr->crc);
crc2_ok = (crc32(0, flash_addr_new->data, ENV_SIZE) == flash_addr_new->crc);
if (crc1_ok && ! crc2_ok) {
gd->env_addr = addr1;
gd->env_valid = 1;
} else if (! crc1_ok && crc2_ok) {
gd->env_addr = addr2;
gd->env_valid = 1;
} else if (! crc1_ok && ! crc2_ok) {
gd->env_addr = addr_default;
gd->env_valid = 0;
} else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
gd->env_addr = addr1;
gd->env_valid = 1;
} else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
gd->env_addr = addr2;
gd->env_valid = 1;
} else if (flag1 == flag2) {
gd->env_addr = addr1;
gd->env_valid = 2;
} else if (flag1 == 0xFF) {
gd->env_addr = addr1;
gd->env_valid = 2;
} else if (flag2 == 0xFF) {
gd->env_addr = addr2;
gd->env_valid = 2;
}
return (0);
}
用了那么多if,else语句,目的就是为了设置gd->env_addr和gd->env_valid这两个变量的值,并且其中还用到了 default_environment这个数组,这个数组在common/env_common.c中定义的,
uchar default_environment[] = {
#ifdef CONFIG_BOOTCOMMAND
"bootcmd=" CONFIG_BOOTCOMMAND "\0"
#endif
#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
"bootdelay=" MK_STR(CONFIG_BOOTDELAY) "\0"
#endif
#if defined(CONFIG_BAUDRATE) && (CONFIG_BAUDRATE >= 0)
"baudrate=" MK_STR(CONFIG_BAUDRATE) "\0"
#endif
#ifdef CONFIG_IPADDR
"ipaddr=" MK_STR(CONFIG_IPADDR) "\0"
#endif
#ifdef CONFIG_SERVERIP
"serverip=" MK_STR(CONFIG_SERVERIP) "\0"
#endif
#ifdef CONFIG_NETMASK
"netmask=" MK_STR(CONFIG_NETMASK) "\0"
#endif
"\0"
};
如果定义了CFG_ENV_IS_IN_NAND的话,就说明一些环境变量存在nand中,这里env_init就是设置了:
gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 1;
这个函数暂时先写到这里,具体就不深入分析了,具体的关系到uboot环境变量的实现分析里面了,我在网上找了一篇文章:
uboot环境变量实现分析:http://blog.csdn.net/skyflying2012/article/details/39005705
这个环境变量的实现分析以后再继续深入研究。
<5> init_baudrate, /* initialze baudrate settings */
static int init_baudrate (void)
{
char tmp[64]; /* long enough for environment variables */
int i = getenv_r ("baudrate", tmp, sizeof (tmp));
gd->bd->bi_baudrate = gd->baudrate = (i > 0)
? (int) simple_strtoul (tmp, NULL, 10)
: CONFIG_BAUDRATE;
return (0);
}
这里面用到了getenv_r这个函数,这个函数在common/cmd_nvedit.c中定义:
int getenv_r (char *name, char *buf, unsigned len)
{
int i, nxt;
for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
int val, n;
for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
if (nxt >= CFG_ENV_SIZE) {
return (-1);
}
}
if ((val=envmatch((uchar *)name, i)) < 0)
continue;
/* found; copy out */
n = 0;
while ((len > n++) && (*buf++ = env_get_char(val++)) != '\0')
;
if (len == n)
*buf = '\0';
return (n);
}
return (-1);
}
这个函数又用到了env_get_char这个函数数组,
uchar (*env_get_char)(int) = env_get_char_init;
static uchar env_get_char_init (int index)
{
uchar c;
/* if crc was bad, use the default environment */
if (gd->env_valid)
{
c = env_get_char_spec(index);
} else {
c = default_environment[index];
}
return (c);
}
阅读完代码后,我们返回 getenv_r这个函数,它的大致意思是根据名字name来从 env_get_char_init中找找有没有设置baudrate,如果存在的话,就保存在buf里面返回,如果没有的话,就返回0。
那么我们再回到 init_baudrate这个函数中,如果getenv_r函数返回波特率的话,就把值存入gd->bd->bi_baudrate中,如果getenv_r函数返回0的话,就使用默认的波特率,即115200。
<6> serial_init, /* serial communications setup */
这个函数在cpu/arm920t/s3c24x0/serial.c中:
int serial_init (void)
{
serial_setbrg ();
return (0);
}
void serial_setbrg (void)
{
S3C24X0_UART * const uart = S3C24X0_GetBase_UART(UART_NR);
int i;
unsigned int reg = 0;
/* value is calculated so : (int)(PCLK/16./baudrate) -1 */
reg = get_PCLK() / (16 * gd->baudrate) - 1;
/* FIFO enable, Tx/Rx FIFO clear */
uart->UFCON = 0x07;
uart->UMCON = 0x0;
/* Normal,No parity,1 stop,8 bit */
uart->ULCON = 0x3;
/*
* tx=level,rx=edge,disable timeout int.,enable rx error int.,
* normal,interrupt or polling
*/
uart->UCON = 0x245;
uart->UBRDIV = reg;
for (i = 0; i < 100; i++);
}
就是完成串口的初始化,但是这里开了FIFO,这个只是uboot源码,用在特殊的板子上的话肯定还需要修改。
<7> console_init_f, /* stage 1 init of console */
int console_init_f (void)
{
gd->have_console = 1;
#ifdef CONFIG_SILENT_CONSOLE
if (getenv("silent") != NULL)
gd->flags |= GD_FLG_SILENT;
#endif
return (0);
}
这里只是将gd->have_console置1,相当于设置了一个标识,表示将会启用uboot的命令终端。
<8> display_banner, /* say that we are here */
此函数在lib_arm/board.c里面定义:
static int display_banner (void)
{
printf ("\n\n%s\n\n", version_string);
debug ("U-Boot code: %08lX -> %08lX BSS: -> %08lX\n",
_armboot_start, _bss_start, _bss_end);
return (0);
}
这个函数只执行了两句话,printf ("\n\n%s\n\n", version_string);就是打印出uboot的一些信息。
const char version_string[] =
U_BOOT_VERSION" (" __DATE__ " - " __TIME__ ")"CONFIG_IDENT_STRING;
#ifndef CONFIG_IDENT_STRING
#define CONFIG_IDENT_STRING ""
#endif
下面分析一下这个printf函数:
printf函数在common/console.c中定义:
void printf (const char *fmt, ...)
{
va_list args;
uint i;
char printbuffer[CFG_PBSIZE];
va_start (args, fmt);
/* For this to work, printbuffer must be larger than
* anything we ever want to print.
*/
i = vsprintf (printbuffer, fmt, args);
va_end (args);
/* Print the string */
puts (printbuffer);
}
CFG_PBSIZE宏在include/config/smdk2410.h中定义:
#define CFG_PROMPT "SMDK2410 # " /* Monitor Command Prompt */
#define CFG_CBSIZE 256 /* Console I/O Buffer Size */
#define CFG_PBSIZE (CFG_CBSIZE+sizeof(CFG_PROMPT)+16) /* Print Buffer Size */
可以看出,printf函数中,先用vsprintf函数对字符串进行了处理,然后用puts打印出来。
vsprintf函数在lib_generic/vsprintf.c里面定义,但是我没看太懂,代码就不粘贴在这里了。
Puts函数在common/console.c中定义:
void puts (const char *s)
{
if (gd->flags & GD_FLG_DEVINIT) {
/* Send to the standard output */
fputs (stdout, s);
} else {
/* Send directly to the handler */
serial_puts (s);
}
}
#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
#define GD_FLG_SILENT 0x00004 /* Silent mode */
这里使用到了gd->flags,代码的意思是根据这一位,选择从哪里输出打印信息,如果定义了GD_FLG_DEVINIT的话,就从标准输出中输出,如果没有定义的话,就从串口中打印。
<9> dram_init, /* configure available RAM banks */
dram_init函数在board/smdk2410/smdk2410.c中定义:
int dram_init (void)
{
gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
return 0;
}
那两个宏定义在smdk2410.h中,如下所示:
#define CONFIG_NR_DRAM_BANKS 1 /* we have 1 bank of DRAM */
#define PHYS_SDRAM_1 0x30000000 /* SDRAM Bank #1 */
#define PHYS_SDRAM_1_SIZE 0x04000000 /* 64 MB */
这个函数主要用来填充gd结构体里面的bd_t结构,bi_dram[0]表示这是板子的第一个sdram,
gd->bd->bi_dram[0].start = PHYS_SDRAM_1;表示这个sdram的起始地址,
gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;表示sdram的大小。
<10> display_dram_config,
display_dram_config这个函数在lib_arm/board.c中定义,如下所示:
static int display_dram_config (void)
{
int i;
#ifdef DEBUG
puts ("RAM Configuration:\n");
for(i=0;
i
printf ("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
print_size (gd->bd->bi_dram[i].size, "\n");
}
#else
ulong size = 0;
for
(i=0; i
size += gd->bd->bi_dram[i].size;
}
puts("DRAM: ");
print_size(size, "\n");
#endif
return (0);
}
这个函数的作用就是打印出这个板子的RAM的一些信息,如大小等。
(7)终于讲完了init_sequence这个函数数组,它完成了一部分的初始化,让我们继续回到start_armboot这个函数中:
#ifndef CFG_NO_FLASH
/* configure available FLASH banks */
size = flash_init ();
display_flash_config (size);
#endif /* CFG_NO_FLASH */
确实没有定义CFG_NO_FLASH这个宏,所以执行下面的语句,
/* armboot_start is defined in the board-specific linker script */
mem_malloc_init (_armboot_start – CFG_MALLOC_LEN);
/* 将堆的内存空间清零。
mem_malloc_init这个函数在lib_arm/board.c中:
void mem_malloc_init (ulong dest_addr)
{
mem_malloc_start = dest_addr;
mem_malloc_end = dest_addr + CFG_MALLOC_LEN;
mem_malloc_brk = mem_malloc_start;
memset ((void *) mem_malloc_start, 0,
mem_malloc_end - mem_malloc_start);
}
memset的定义如下:
void * memset(void * s,int c,size_t count)
{
char *xs = (char *) s;
while (count--)
*xs++ = c;
return s;
}
在这个程序中,_armboot_start = 0x33f80000, CFG_MALLOC_LEN是定义的堆的内存大小,将这一段空间清零。*/
(8)继续在start_armboot中执行:
#if (CONFIG_COMMANDS & CFG_CMD_NAND)
puts ("NAND: ");
nand_init(); /* go init the NAND */
#endif
/* nand_init函数在drivers/nand/nand.c中定义:
void nand_init(void)
{
int i;
unsigned int size = 0;
for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {
nand_init_chip(&nand_info[i], &nand_chip[i], base_address[i]);
size += nand_info[i].size;
if (nand_curr_device == -1)
nand_curr_device = i;
}
printf("%lu MiB\n", size / (1024 * 1024));
}
我们看到这里有一个for循环,有一个CFG_MAX_NAND_DEVICE宏,表示板子有几个nand flash,所以如果要移植这个uboot的话,需要在配置文件中定义这个宏,这个函数里面包含了一个nand_init_chip函数,除此之外,计算出nand flash的总大小,保存在这个nand_info结构体中,nand_curr_device表示当前nand flash设备编号,初始值为-1(在文件前面定义初始化的),因为我们只有一个nand flash 设备,所以这个值应该为0,之后打印出来这个nand flash的大小。
之后我们再进入nand_init_chip这个函数,
static void nand_init_chip(struct mtd_info *mtd, struct nand_chip *nand,
ulong base_addr)
{
mtd->priv = nand;
nand->IO_ADDR_R = nand->IO_ADDR_W = (void __iomem *)base_addr;
board_nand_init(nand);
if (nand_scan(mtd, 1) == 0) {
if (!mtd->name)
mtd->name = (char *)default_nand_name;
} else
mtd->name = NULL;
}
在看这个函数之前,我们要看传递给这个函数的三个参数,nand_info、 nand_chip和base_address。这三个参数它们都是定义在nand.c中的三个全局变量,用于保存nand flash的相关信息,这就是初始化要的关键。nand_info主要和芯片本身相关,比如记录nand flash的大小等等。nand_chip这个结构主要记录nand flash它的操作相关,比如read、wirte等等。而base_address是记录的nand flash主控制器的寄存器基地址。它是这样定义的。
#ifndef
CONFIG_SYS_NAND_BASE_LIST
#define CONFIG_SYS_NAND_BASE_LIST {
CONFIG_SYS_NAND_BASE }
#endif
nand_info_t nand_info[CFG_MAX_NAND_DEVICE];
static struct nand_chip nand_chip[CFG_MAX_NAND_DEVICE];
static ulong base_address[CONFIG_SYS_MAX_NAND_DEVICE] = CONFIG_SYS_NAND_BASE_LIST;
如果没有定义CONFIG_SYS_NAND_BASE_LIST,那么寄存器基地址就是CONFIG_SYS_NAND_BASE,对于S3C2410呢这个值就为0x4E000000,所以在移植的时候又需要在配置文件中定义这个宏。
这个函数的核心就是两个函数,board_nand_init()函数和 nand_scan()函数。
这个board_nand_init()函数一看就是与板子相关的函数,我们搜遍uboot源码都没有找到这个函数,所以这个函数是需要我们实现的函数,现在参考网上的资料,也可能是在以后的uboot版本中支持了,在这列举一些这个函数的大概框架:
int
board_nand_init(struct nand_chip *nand)
{
u_int32_t cfg;
u_int8_t tacls,
twrph0, twrph1;
S3C24X0_CLOCK_POWER *
const clk_power = S3C24X0_GetBase_CLOCK_POWER();
clk_power->CLKCON |= (1 << 4);
/* initialize hardware */
twrph0 = 3; twrph1 = 0; tacls = 0;
cfg = S3C2410_NFCONF_EN;
cfg |=
S3C2410_NFCONF_TACLS(tacls - 1);
cfg
|= S3C2410_NFCONF_TWRPH0(twrph0 - 1);
cfg |= S3C2410_NFCONF_TWRPH1(twrph1 - 1);
NFCONF = cfg;
/* initialize
nand_chip data structure */
nand->IO_ADDR_R = nand->IO_ADDR_W = (void *)0x4e00000c;
/* read_buf and write_buf are default */
/* read_byte and write_byte are default */
/* hwcontrol always must be implemented */
nand->cmd_ctrl = s3c2410_hwcontrol;
nand->dev_ready = s3c2410_dev_ready;
#ifdef
CONFIG_S3C2410_NAND_HWECC
nand->ecc.hwctl = s3c2410_nand_enable_hwecc;
nand->ecc.calculate = s3c2410_nand_calculate_ecc;
nand->ecc.correct
= s3c2410_nand_correct_data;
nand->ecc.mode = NAND_ECC_HW3_512;
#else
nand->ecc.mode = NAND_ECC_SOFT;
#endif
nand->options = 0;
DEBUGN("end of nand_init\n");
return 0;
}
这个函数首先置CLKCON第5位,给nand控制器供电,上电默认是供电的,然后配置NFCONF寄存器,设置nand flash读写基地址为0x4e00000c,然后填充nand_chip结构体。
nand_scan()这个函数位于drivers/nand/nand_base.c这个文件中,这段代码很长,但是不难分析,主要的目的是填充nand_chip结构体,我在后面列出了这个结构体(也是很大。。。)简单分析如下:
int nand_scan (struct mtd_info *mtd, int maxchips)
{
int i, j, nand_maf_id, nand_dev_id, busw;
struct nand_chip *this = mtd->priv;
/* Get buswidth to select the correct functions*/
busw = this->options & NAND_BUSWIDTH_16; /* 设置位宽 */
/* check for proper chip_delay setup, set 20us if not */
if (!this->chip_delay)
this->chip_delay = 20;
/* check, if a user supplied command function given */
if (this->cmdfunc == NULL)
this->cmdfunc = nand_command;
/* check, if a user supplied wait function given */
if (this->waitfunc == NULL)
this->waitfunc = nand_wait;
if (!this->select_chip)
this->select_chip = nand_select_chip;
if (!this->write_byte)
this->write_byte = busw ? nand_write_byte16 : nand_write_byte;
if (!this->read_byte)
this->read_byte = busw ? nand_read_byte16 : nand_read_byte;
if (!this->write_word)
this->write_word = nand_write_word;
if (!this->read_word)
this->read_word = nand_read_word;
if (!this->block_bad)
this->block_bad = nand_block_bad;
if (!this->block_markbad)
this->block_markbad = nand_default_block_markbad;
if (!this->write_buf)
this->write_buf = busw ? nand_write_buf16 : nand_write_buf;
if (!this->read_buf)
this->read_buf = busw ? nand_read_buf16 : nand_read_buf;
if (!this->verify_buf)
this->verify_buf = busw ? nand_verify_buf16 : nand_verify_buf;
if (!this->scan_bbt)
this->scan_bbt = nand_default_bbt;
/* 以上代码就是判断这些nand_chip成员是否初始化,如果没有的话,就给它们赋值 */
/* Select the device */
this->select_chip(mtd, 0); /* 选中芯片 */
/* Send the command for reading device ID */
this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1); /* 这个一个发送命令的函数 */
/* Read manufacturer and device IDs */
nand_maf_id = this->read_byte(mtd); /* 对于三星来说,厂商ID为0xec */
nand_dev_id = this->read_byte(mtd); /* 这个是设备ID,以k9f1208为例是0x76 */
/* Print and store flash device information */
for (i = 0; nand_flash_ids[i].name != NULL; i++) {
if (nand_dev_id != nand_flash_ids[i].id)
continue;
/* 根据这个设备ID:nand_dev_id从这个nand_flash_ids[i]数组中找出匹配的一项,该项上含有芯片的一些信息,这个数组在drivers/nand/nand_ids.c中,列举部分如下:
struct nand_flash_dev nand_flash_ids[] = {
{"NAND 1MiB 5V 8-bit", 0x6e, 256, 1, 0x1000, 0},
{"NAND 2MiB 5V 8-bit", 0x64, 256, 2, 0x1000, 0},
{"NAND 4MiB 5V 8-bit", 0x6b, 512, 4, 0x2000, 0},
{"NAND 1MiB 3,3V 8-bit", 0xe8, 256, 1, 0x1000, 0},
{"NAND 1MiB 3,3V 8-bit", 0xec, 256, 1, 0x1000, 0},
{"NAND 2MiB 3,3V 8-bit", 0xea, 256, 2, 0x1000, 0},
。。。
{NULL,}
};
对于此块nand,读出nand_dev_id为0x76后,则在nand_flash_ids[]中匹配到下面这一项:{"NAND 64MiB 3,3V 8-bit", 0x76, 512, 64, 0x4000, 0},由此可知,页面大小为512bytes, 芯片容量为64M, 擦写页面大小为16k等。 */
if (!mtd->name) mtd->name = nand_flash_ids[i].name;
/* mtd->name就指向字符串"NAND 64MiB 3,3V 8-bit" */
this->chipsize = nand_flash_ids[i].chipsize << 20;
/* 芯片大小为64M,即0x4000000 */
/* New devices have all the information in additional id bytes */
if (!nand_flash_ids[i].pagesize) {
。。。。/* 这个if语句不会执行,会执行else分支,所以我把代码删了 */
} else {
/* Old devices have this data hardcoded in the
* device id table */
mtd->erasesize = nand_flash_ids[i].erasesize; /*擦除页大小为16k*/
mtd->oobblock = nand_flash_ids[i].pagesize;/*页大小为512bytes*/
mtd->oobsize = mtd->oobblock / 32; /*oob大小为16bytes*/
busw = nand_flash_ids[i].options & NAND_BUSWIDTH_16; /*busw=0*/
} /* 上述这些信息都是刚才从nand_flash_ids[]中找到的,将他们赋给mtd结构体 */
/* Check, if buswidth is correct. Hardware drivers should set
* this correct ! */
if (busw != (this->options & NAND_BUSWIDTH_16)) {
printk (KERN_INFO "NAND device: Manufacturer ID:"
" 0x%02x, Chip ID: 0x%02x (%s %s)\n", nand_maf_id, nand_dev_id,
nand_manuf_ids[i].name , mtd->name);
printk (KERN_WARNING
"NAND bus width %d instead %d bit\n",
(this->options & NAND_BUSWIDTH_16) ? 16 : 8,
busw ? 16 : 8);
this->select_chip(mtd, -1);
return 1;
}
/* Calculate the address shift from the page size */
this->page_shift = ffs(mtd->oobblock) - 1;
this->bbt_erase_shift = this->phys_erase_shift = ffs(mtd->erasesize) - 1;
this->chip_shift = ffs(this->chipsize) – 1;
/*
#define ffs(x) generic_ffs(x)
/* Return the position of the first
bit set in 1, or 0 if none are set. The least-significant bit is
position 1, the most-significant 32. */
找出第一个为1的位,最低位为1
即 0x1000
0000 0000 0000 0000 0000 0000 0000 返回32
0x0001 返回1
所以这里 ffs(mtd->oobblock) = 10
, this->page_shift = 9
this->bbt_erase_shift =
this->phys_erase_shift = 13
this->chip_shift = 26 */
/* Set the bad block position */
this->badblockpos = mtd->oobblock > 512 ?
NAND_LARGE_BADBLOCK_POS : NAND_SMALL_BADBLOCK_POS;
/* 判断是大页还是小页,来确定坏块的标记位置, this->badblockpos大页的话=0,小页=5。 */
/* Get chip options, preserve non chip based options */
this->options &= ~NAND_CHIPOPTIONS_MSK;
this->options |= nand_flash_ids[i].options & NAND_CHIPOPTIONS_MSK;
/* Set this as a default. Board drivers can override it, if neccecary */
this->options |= NAND_NO_AUTOINCR;
/* 应该是设置nand flash的一些属性类的东西,没有深入研究。 */
/* Check if this is a not a samsung device. Do not clear the options
* for chips which are not having an extended id.
*/
if (nand_maf_id != NAND_MFR_SAMSUNG && !nand_flash_ids[i].pagesize)
this->options &= ~NAND_SAMSUNG_LP_OPTIONS;
/* Check for AND chips with 4 page planes */
if (this->options & NAND_4PAGE_ARRAY)
this->erase_cmd = multi_erase_cmd;
else
this->erase_cmd = single_erase_cmd;
/* Do not replace user supplied command function ! */
if (mtd->oobblock > 512 && this->cmdfunc == nand_command)
this->cmdfunc = nand_command_lp;
/* Try to identify manufacturer */
for (j = 0; nand_manuf_ids[j].id != 0x0; j++) {
if (nand_manuf_ids[j].id == nand_maf_id)
break;
}
break;
}
if (!nand_flash_ids[i].name) {
printk (KERN_WARNING "No NAND device found!!!\n");
this->select_chip(mtd, -1);
return 1;
}
for (i=1; i < maxchips; i++) {
this->select_chip(mtd, i);
/* Send the command for reading device ID */
this->cmdfunc (mtd, NAND_CMD_READID, 0x00, -1);
/* Read manufacturer and device IDs */
if (nand_maf_id != this->read_byte(mtd) ||
nand_dev_id != this->read_byte(mtd))
break;
} /* 如果有多个nand flash的话,一次去读他们的ID,但是,nand_scan的调用为 * nand_scan(mtd, 1), 即maxchips == 1,所以这一段代码不会执行。 */
if (i > 1)
printk(KERN_INFO "%d NAND chips detected\n", i);
/* Allocate buffers, if neccecary */
if (!this->oob_buf) {
size_t len;
len = mtd->oobsize << (this->phys_erase_shift – this->page_shift);
/* len = 16 << (13 - 9) = 256 */
this->oob_buf = kmalloc (len, GFP_KERNEL);
if (!this->oob_buf) {
printk (KERN_ERR "nand_scan(): Cannot allocate oob_buf\n");
return -ENOMEM;
}
this->options |= NAND_OOBBUF_ALLOC;
}
if (!this->data_buf) {
size_t len;
len = mtd->oobblock + mtd->oobsize; /* len = 512 + 16 \ 528 */
this->data_buf = kmalloc (len, GFP_KERNEL);
if (!this->data_buf) {
if (this->options & NAND_OOBBUF_ALLOC)
kfree (this->oob_buf);
printk (KERN_ERR "nand_scan(): Cannot allocate data_buf\n");
return -ENOMEM;
}
this->options |= NAND_DATABUF_ALLOC;
}
/* Store the number of chips and calc total size for mtd */
this->numchips = i; /* 芯片数目 */
mtd->size = i * this->chipsize; /* 总大小 */
/* Convert chipsize to number of pages per chip -1. */
this->pagemask = (this->chipsize >> this->page_shift) - 1;
/* Preset the internal oob buffer */
memset(this->oob_buf, 0xff, mtd->oobsize << (this->phys_erase_shift - this->page_shift));
/* If no default placement scheme is given, select an
* appropriate one */
if (!this->autooob) {
/* Select the appropriate default oob placement scheme for
* placement agnostic filesystems */
switch (mtd->oobsize) {
case 8:
this->autooob = &nand_oob_8;
break;
case 16:
this->autooob = &nand_oob_16;
break;
case 64:
this->autooob = &nand_oob_64;
break;
default:
printk (KERN_WARNING "No oob scheme defined for oobsize %d\n",
mtd->oobsize);
/* BUG(); */
}
}
/* The number of bytes available for the filesystem to place fs dependend
* oob data */
if (this->options & NAND_BUSWIDTH_16) {
mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 2);
if (this->autooob->eccbytes & 0x01)
mtd->oobavail--;
} else
mtd->oobavail = mtd->oobsize - (this->autooob->eccbytes + 1);
/* 上面的代码是填充oob的一些东西。 */
/*
* check ECC mode, default to software
* if 3byte/512byte hardware ECC is selected and we have 256 byte pagesize
* fallback to software ECC
*/
this->eccsize = 256; /* set default eccsize */
this->eccbytes = 3;
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
if (mtd->oobblock < 2048) {
printk(KERN_WARNING "2048 byte HW ECC not possible on %d byte page size, fallback to SW ECC\n",
mtd->oobblock);
this->eccmode = NAND_ECC_SOFT;
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
} else
this->eccsize = 2048;
break;
case NAND_ECC_HW3_512:
case NAND_ECC_HW6_512:
case NAND_ECC_HW8_512:
if (mtd->oobblock == 256) {
printk (KERN_WARNING "512 byte HW ECC not possible on 256 Byte pagesize, fallback to SW ECC \n");
this->eccmode = NAND_ECC_SOFT;
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
} else
this->eccsize = 512; /* set eccsize to 512 */
break;
case NAND_ECC_HW3_256:
break;
case NAND_ECC_NONE:
printk (KERN_WARNING "NAND_ECC_NONE selected by board driver. This is not recommended !!\n");
this->eccmode = NAND_ECC_NONE;
break;
case NAND_ECC_SOFT:
this->calculate_ecc = nand_calculate_ecc;
this->correct_data = nand_correct_data;
break;
default:
printk (KERN_WARNING "Invalid NAND_ECC_MODE %d\n", this->eccmode);
/* BUG(); */
}
/* Check hardware ecc function availability and adjust number of ecc bytes per
* calculation step
*/
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
this->eccbytes += 4;
case NAND_ECC_HW8_512:
this->eccbytes += 2;
case NAND_ECC_HW6_512:
this->eccbytes += 3;
case NAND_ECC_HW3_512:
case NAND_ECC_HW3_256:
if (this->calculate_ecc && this->correct_data && this->enable_hwecc)
break;
printk (KERN_WARNING "No ECC functions supplied, Hardware ECC not possible\n");
/* BUG(); */
}
mtd->eccsize = this->eccsize;
/* Set the number of read / write steps for one page to ensure ECC generation */
switch (this->eccmode) {
case NAND_ECC_HW12_2048:
this->eccsteps = mtd->oobblock / 2048;
break;
case NAND_ECC_HW3_512:
case NAND_ECC_HW6_512:
case NAND_ECC_HW8_512:
this->eccsteps = mtd->oobblock / 512;
break;
case NAND_ECC_HW3_256:
case NAND_ECC_SOFT:
this->eccsteps = mtd->oobblock / 256;
break;
case NAND_ECC_NONE:
this->eccsteps = 1;
break;
}
/* 上面的代码是设置ECC一类的东西,比如说硬件ECC或者软件ECC等。 */
/* De-select the device */
this->select_chip(mtd, -1); /* 取消片选芯片 */
/* Invalidate the pagebuffer reference */
this->pagebuf = -1;
/* Fill in remaining MTD driver data */
mtd->type = MTD_NANDFLASH;
mtd->flags = MTD_CAP_NANDFLASH | MTD_ECC;
mtd->ecctype = MTD_ECC_SW;
mtd->erase = nand_erase;
mtd->point = NULL;
mtd->unpoint = NULL;
mtd->read = nand_read;
mtd->write = nand_write;
mtd->read_ecc = nand_read_ecc;
mtd->write_ecc = nand_write_ecc;
mtd->read_oob = nand_read_oob;
mtd->write_oob = nand_write_oob;
mtd->sync = nand_sync;
mtd->block_isbad = nand_block_isbad;
mtd->block_markbad = nand_block_markbad;
/* 以上的代码就是填充mtd结构体 */
/* and make the autooob the default one */
memcpy(&mtd->oobinfo, this->autooob, sizeof(mtd->oobinfo));
/* Build bad block table */
return this->scan_bbt (mtd); /* 建立坏块列表 */
}
终于分析完了这两个函数,可以看出来里面最重要的就是nand_chip和mtd_info这两个结构体,由于这两个结构体成员众多,下面就不粘贴出来这两个结构体了,mtd_info结构体位于include/linux/mtd/mtd.h中,nand_chip结构体位于include/linux/mtd/nand.h中。*/
(9)执行完nand_init函数以后,我们继续返回到start_armboot函数中往下执行:
/* initialize environment */
env_relocate ();
/* 这个函数位于common/env_common.c文件中:
void env_relocate (void)
{
DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__,
gd->reloc_off);
/*
* We must allocate a buffer for the environment
*/
env_ptr = (env_t *)malloc (CFG_ENV_SIZE);
DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
/* CFG_ENV_SIZE这个宏在include/config/smdk2410.h中定义,为0x10000。这里从malloc堆里面分配出来0x10000这么大的空间,并将 env_ptr指向它。 */
/*
* After relocation to RAM, we can always use the "memory" functions
*/
env_get_char = env_get_char_memory; /* 这个函数没看懂。。。 */
if (gd->env_valid == 0) {
#if defined(CONFIG_GTH) || defined(CFG_ENV_IS_NOWHERE) /* Environment not changable */
puts ("Using default environment\n\n");
#else
puts ("*** Warning - bad CRC, using default environment\n\n");
SHOW_BOOT_PROGRESS (-1);
#endif
if (sizeof(default_environment) > ENV_SIZE)
{
puts ("*** Error - default environment is too large\n\n");
return;
}
memset (env_ptr, 0, sizeof(env_t));
memcpy (env_ptr->data,
default_environment,
sizeof(default_environment));
#ifdef CFG_REDUNDAND_ENVIRONMENT
env_ptr->flags = 0xFF;
#endif
env_crc_update ();
gd->env_valid = 1;
}
else {
env_relocate_spec ();
}
gd->env_addr = (ulong)&(env_ptr->data);
}
/* 对于这个if语句,在前面那个init_sequence数组里面的env_init函数,它已经设置了
gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 1;
所以这个if语句不会执行,会执行它的else分支,我在上面用红色字体标出来了。
关于这个env_relocate_spec()函数,也是单板相关的函数,在common/env_nand.c中:
void env_relocate_spec (void)
{
#if !defined(ENV_IS_EMBEDDED)
ulong total;
int ret;
total = CFG_ENV_SIZE;
ret = nand_read(&nand_info[0], CFG_ENV_OFFSET, &total, (u_char*)env_ptr);
if (ret || total != CFG_ENV_SIZE)
return use_default();
if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
return use_default();
#endif /* ! ENV_IS_EMBEDDED */
}
环境变量存在nand中,将其从nand中读出,并填入env_ptr指向的env_t结构里,从nand读出时,配置项中有 CFG_ENV_OFFSET,即环境变量在nand中存储的起始地址。数据读错或数据校验出错,都会使用默认的环境变量配置use_default(),
第一次运行uboot时板子会打印如下信息:
*** Warning - bad CRC or NAND, using default
environment
就是因为读出的数据经过crc32校验出错(此时读出的数据不是环境变量),进而调用use_default(),在
use_default()中会打印该信息。use_default()函数同样在common/env_nand.c中,如下所示:
static void use_default()
{
puts ("*** Warning - bad CRC or NAND, using default environment\n\n");
if (default_environment_size > CFG_ENV_SIZE){
puts ("*** Error - default environment is too large\n\n");
return;
}
memset (env_ptr, 0, sizeof(env_t));
memcpy (env_ptr->data,
default_environment,
default_environment_size);
env_ptr->crc = crc32(0, env_ptr->data, ENV_SIZE);
gd->env_valid = 1;
} */
env_relocate 函数的最后一行又将gd->env_addr指向env_ptr->data。
小结;env_relocate()函数所做的事情有3件:
1. 从heap中分配一段空间,用于env_t结构
2. 找到环境变量(或从内存中找或从nand中找),填充env_t结构
3. 将gd->env_addr指向env_ptr->data,
这个也就是这里的relocate所在吧。
*/
(10)继续在start_armboot函数中执行:
/* IP Address */
gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
/* 将环境变量设置完之后,紧接着就是从环境变量的相应项中获取信息,环境变量是用户与u-boot的一个交互方式,有了它之后,用户即可通过修改环境变量来修改板子的一些信息配置。这里的ip地址和网卡地址即是其中的一个典型例子。来看上面的代码, 通过getenv_IPaddr函数来获取ip地址,然后将它保存在gd->bd->bi_ip_addr里面,注意gd->bd->bi_ip_addr是ungisned long 类型,而ip地址是类似于"192.168.1.111"的字符串,我们继续往下看代码,getenv_IPaddr()函数net/net.c中:
IPaddr_t getenv_IPaddr (char *var)
{
return (string_to_ip(getenv(var)));
}
继续追踪,getenv()函数在common/cmd_nvedit.c中定义,如下所示:
char *getenv (char *name)
{
int i, nxt;
WATCHDOG_RESET();
for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
int val;
for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
if (nxt >= CFG_ENV_SIZE) {
return (NULL);
}
}
if ((val=envmatch((uchar *)name, i)) < 0)
continue;
return ((char *)env_get_addr(val));
}
return (NULL);
}
getenv("ipaddr")即在环境变量中找到ipaddr这一项对应的字符串,假设这里为"192.168.1.111"
将"192.168.1.111"传入string_to_ip。 IPaddr_t 类型是unsigned
long 的一个typedef。
IPaddr_t string_to_ip(char *s)
{
IPaddr_t addr;
char *e;
int i;
if (s == NULL)
return(0);
for (addr=0, i=0; i<4; ++i) {
ulong val = s ? simple_strtoul(s, &e, 10) : 0;
addr <<= 8;
addr |= (val & 0xFF);
if (s) {
s = (*e) ? e+1 : e;
}
}
return (htonl(addr));
}
192.168.1.111 分为四个段,也就是要做4次 simple_strtoul()转换成10进制的整型
第4次转换后的值赋给val。addr是unsigned
long型,32位的,将其分为4段,每8位存储ip地址中的一个段,最后addr
= (((((192 << 8) | 168)
<< 8) | 1) << 8 ) | 111 = 0xc0a8016f。
最后一行,htonl(addr)表示主机字节顺序转换为网络字节顺序返回。那么什么叫做网络字节顺序呢?
若CPU为小端模式时,addr如下存储:
31
24 23 16 15 8 7
0
+--------------+---------------+----------------+-----------------+
|
192 = 0xc0 | 168 = 0xa8 | 1 = 0x01 | 111 = 0x6f
|
+--------------+---------------+----------------+-----------------+
3 2 1 0
若CPU为大端模式时,addr如下存储:
31
24 23 16 15 8 7
0
+--------------+---------------+----------------+-----------------+
|
111 = 0x6f | 1 = 0x01 | 168 = 0xa8 | 192 = 0xc0
|
+--------------+---------------+----------------+-----------------+
3 2 1 0
当与另一台计算机通信时,通常不知道对方存储数据时是先存放最高位字节 (MSB)还是最低位字节 (LSB)
恰恰网络字节顺序跟大端模式时相同,htonl函数就是将主机字节顺序转为网络字节顺序,在最高位字节
(MSB)-最前的系统上,这个函数什么都不做。在最低位字节(LSB)-最前的系统上它们将值转换为正确的
顺序。
最后将值返回给了gd->bd->bi_ip_addr,
所以其值应该是0x6f01800a。 */
(11)继续在start_armboot函数中执行:
/* MAC Address */
{
int i;
ulong reg;
char *s, *e;
char tmp[64];
i = getenv_r ("ethaddr", tmp, sizeof (tmp));
s = (i > 0) ? tmp : NULL;
for (reg = 0; reg < 6; ++reg) {
gd->bd->bi_enetaddr[reg] = s ? simple_strtoul (s, &e, 16) : 0;
if (s)
s = (*e) ? e + 1 : e;
}
}
/* 网卡地址以十六进制的形式存于gd->bd->bi_enetaddr[]数组中 */
(12) 继续在start_armboot函数中执行:
devices_init (); /* get the devices list going. */
/* 在start_armboot简单的一句话,它的底层函数很多。。。对于这个设备初始化函数同样是这样,下面慢慢来分析这个函数,这个函数在common/devices.c:
int devices_init (void)
{
#ifndef CONFIG_ARM /* already relocated for current ARM implementation */
ulong relocation_offset = gd->reloc_off;
int i;
/* relocate device name pointers */
for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
relocation_offset);
}
#endif
/* Initialize the list */
devlist = ListCreate (sizeof (device_t));
if (devlist == NULL) {
eputs ("Cannot initialize the list of devices!\n");
return -1;
}
#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
#endif
#ifdef CONFIG_LCD
drv_lcd_init ();
#endif
#if defined(CONFIG_VIDEO) || defined(CONFIG_CFB_CONSOLE)
drv_video_init ();
#endif
#ifdef CONFIG_KEYBOARD
drv_keyboard_init ();
#endif
#ifdef CONFIG_LOGBUFFER
drv_logbuff_init ();
#endif
drv_system_init ();
#ifdef CONFIG_SERIAL_MULTI
serial_devices_init ();
#endif
#ifdef CONFIG_USB_TTY
drv_usbtty_init ();
#endif
#ifdef CONFIG_NETCONSOLE
drv_nc_init ();
#endif
return (0);
}
首先并没有定义这个CONFIG_ARM宏,所以执行这个#ifndef这个语句,在本文件的开头有这样的声明:
char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };
首先将gd->reloc_off的值赋给relocation_offset,然后重定位stdio_names[]这个数组里面的每一项。
然后就是这个ListCreate函数了,我们先分析了这个函数整体以后再分析这个ListCreate函数。这个函数的作用就是创建一个设备列表,列表里面包含所有用到的设备。
然后这个函数后面,可以看出来有很多宏,比如CONFIG_KEYBOARD,CONFIG_SERIAL_MULTI,CONFIG_USB_TTY等,如果想使用键盘,串口,和USB设备等的话,就定义这些宏。
接下来分析这个ListCreate函数。
list_t ListCreate (int elementSize)
{
list_t list;
list = (list_t) (NewHandle (sizeof (ListStruct))); /* create empty list */
if (list) {
(*list)->signature = LIST_SIGNATURE;
(*list)->numItems = 0;
(*list)->listSize = 0;
(*list)->itemSize = elementSize;
(*list)->percentIncrease = kDefaultAllocationPercentIncrease;
(*list)->minNumItemsIncrease =
kDefaultAllocationminNumItemsIncrease;
}
return list;
}
这个函数传进来的参数是sizeof (device_t),调用 NewHandle函数创建一个空的list,并将这个函数的非0返回值强制类型转换成list_t类型,然后填充这个list_t结构体。
NewHandle函数位于common/list.c中:
Handle NewHandle (unsigned int numBytes)
{
void *memPtr;
HandleRecord *hanPtr;
memPtr = calloc (numBytes, 1);
hanPtr = (HandleRecord *) calloc (sizeof (HandleRecord), 1);
if (hanPtr && (memPtr || numBytes == 0)) {
hanPtr->ptr = memPtr;
hanPtr->size = numBytes;
return (Handle) hanPtr;
} else {
free (memPtr);
free (hanPtr);
return NULL;
}
}
#define calloc(size,num) malloc(size*num)
这个NewHandle函数传进来的参数是sizeof (ListStruct),给 memPtr和 hanPtr分配了内存,如果分配成功的话,就填充 hanPtr这个结构体。
这一段用到了很多结构体,如list_t, HandleRecord等等,我就不一一列举了。
分析完底层的函数,我们继续返回到devices_init这个函数,在u-boot-1.1.6中,默认没有定义任何一个宏,但是我们肯定是需要用到这些设备中的一个或几个的,现在挑一个常用的串口设备来分析一个这个serial_devices_init()函数。这个函数在common/serial.c中:
void serial_devices_init (void)
{
device_t dev;
struct serial_device *s = serial_devices;
while (s) {
memset (&dev, 0, sizeof (dev));
strcpy (dev.name, s->name);
dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
dev.start = s->init;
dev.putc = s->putc;
dev.puts = s->puts;
dev.getc = s->getc;
dev.tstc = s->tstc;
device_register (&dev);
s = s->next;
}
}
分析代码发现,在这个文件的开头,首先定义了static struct serial_device *serial_devices = NULL;然后将这个serial_devices作为链表头,遍历这个链表中的每一项,分别为这个链表中的每一个串口设备初始化,即填充device_t这个结构体,这个结构体肯定是设备专属的结构体。既然有遍历列表的操作,那么肯定有往列表里面注册设备的操作,果然在函数的最后,有这个device_register (&dev)函数,下面分析这个注册函数。一路跟踪下去:
int device_register (device_t * dev)
{
ListInsertItem (devlist, dev, LIST_END);
return 0;
}
int ListInsertItem (list_t list, void *ptrToItem, int itemPosition)
{
return ListInsertItems (list, ptrToItem, itemPosition, 1);
}
int ListInsertItems (list_t list, void *ptrToItems, int firstItemPosition,
int numItemsToInsert)
{
int numItems = (*list)->numItems;
if (firstItemPosition == numItems + 1)
firstItemPosition = LIST_END;
else if (firstItemPosition > numItems)
return 0;
if ((*list)->numItems >= (*list)->listSize) {
if (!ExpandListSpace (list, -numItemsToInsert))
return 0;
}
if (firstItemPosition == LIST_START) {
if (numItems == 0) {
/* special case for empty list */
firstItemPosition = LIST_END;
} else {
firstItemPosition = 1;
}
}
if (firstItemPosition == LIST_END) { /* add at the end of the list */
if (ptrToItems)
memcpy (ITEMPTR (list, numItems), ptrToItems,
(*list)->itemSize * numItemsToInsert);
else
memset (ITEMPTR (list, numItems), 0,
(*list)->itemSize * numItemsToInsert);
(*list)->numItems += numItemsToInsert;
} else { /* move part of list up to make room for new item */
memmove (ITEMPTR (list, firstItemPosition - 1 + numItemsToInsert),
ITEMPTR (list, firstItemPosition - 1),
(numItems + 1 - firstItemPosition) * (*list)->itemSize);
if (ptrToItems)
memmove (ITEMPTR (list, firstItemPosition - 1), ptrToItems,
(*list)->itemSize * numItemsToInsert);
else
memset (ITEMPTR (list, firstItemPosition - 1), 0,
(*list)->itemSize * numItemsToInsert);
(*list)->numItems += numItemsToInsert;
}
return 1;
}
这些函数做的功能大致就是往设备列表list中注册第一个设备“serial”,为这个设备分配空间,然后这个链表中的设备数目增加。具体怎么执行就不分析了。
*/
(13)继续在start_armboot函数中执行:
jumptable_init ();
/* 这个 jumptable_init函数位于common/exports.c里面:
void jumptable_init (void)
{
int i;
gd->jt = (void **) malloc (XF_MAX * sizeof (void *));
for (i = 0; i < XF_MAX; i++)
gd->jt[i] = (void *) dummy;
gd->jt[XF_get_version] = (void *) get_version;
gd->jt[XF_malloc] = (void *) malloc;
gd->jt[XF_free] = (void *) free;
gd->jt[XF_getenv] = (void *) getenv;
gd->jt[XF_setenv] = (void *) setenv;
gd->jt[XF_get_timer] = (void *) get_timer;
gd->jt[XF_simple_strtoul] = (void *) simple_strtoul;
gd->jt[XF_udelay] = (void *) udelay;
#if defined(CONFIG_I386) || defined(CONFIG_PPC)
gd->jt[XF_install_hdlr] = (void *) irq_install_handler;
gd->jt[XF_free_hdlr] = (void *) irq_free_handler;
#endif /* I386 || PPC */
#if (CONFIG_COMMANDS & CFG_CMD_I2C)
gd->jt[XF_i2c_write] = (void *) i2c_write;
gd->jt[XF_i2c_read] = (void *) i2c_read;
#endif /* CFG_CMD_I2C */
}
分析这个函数,发现它就是填充gd_t结构体里面的jt成员,具体这个成员是干嘛的,还不太了解。*/
(14)继续在start_armboot函数中执行:
console_init_r (); /* fully init console as a device */
/* console_init_r这个函数在common/console.c中,这个函数也是有两个,根据CFG_CONSOLE_IS_IN_ENV这个宏选择用哪个函数,在2410中没有定义这个宏,所以我们选择第二个console_init_r函数,如下所示:
/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
device_t *inputdev = NULL, *outputdev = NULL;
int i, items = ListNumItems (devlist);
/* 通过这个 ListNumItems函数,获取list链表中的设备个数。
int ListNumItems (list_t list)
{
return (*list)->numItems;
} */
#ifdef CONFIG_SPLASH_SCREEN /* 没有定义 */
/* suppress all output if splash screen is enabled and we have
a bmp to display */
if (getenv("splashimage") != NULL)
outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif
#ifdef CONFIG_SILENT_CONSOLE /* 没有定义 */
/* Suppress all output if "silent" mode requested */
if (gd->flags & GD_FLG_SILENT)
outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif
/* Scan devices looking for input and output devices */
for (i = 1;
(i <= items) && ((inputdev == NULL) || (outputdev == NULL));
i++
) {
device_t *dev = ListGetPtrToItem (devlist, i);
if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
inputdev = dev;
}
if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
outputdev = dev;
}
}
/* 遍历list链表,根据每个设备对应的device_t结构体中的flags属性来选择出输入输出设备。
ListGetPtrToItem函数就是把devlist链表中的每一项都赋给dev,然后分别将 dev->flags与 DEV_FLAGS_INPUT和 DEV_FLAGS_OUTPUT所对比,以此来挑选出输入输出设备。这些都是链表的基本操作。 */
/* Initializes output console first */
if (outputdev != NULL) {
console_setfile (stdout, outputdev);
console_setfile (stderr, outputdev);
}
/* Initializes input console */
if (inputdev != NULL) {
console_setfile (stdin, inputdev);
}
/* 这里用到了console_setfile函数,这个函数在common/console.c函数中, 如下所示:
static int console_setfile (int file, device_t * dev)
{
int error = 0;
if (dev == NULL)
return -1;
switch (file) {
case stdin:
case stdout:
case stderr:
/* Start new device */
if (dev->start) {
error = dev->start ();
/* If it's not started dont use it */
if (error < 0)
break;
}
/* Assign the new device (leaving the existing one started) */
stdio_devices[file] = dev;
/*
* Update monitor functions
* (to use the console stuff by other applications)
*/
switch (file) {
case stdin:
gd->jt[XF_getc] = dev->getc;
gd->jt[XF_tstc] = dev->tstc;
break;
case stdout:
gd->jt[XF_putc] = dev->putc;
gd->jt[XF_puts] = dev->puts;
gd->jt[XF_printf] = printf;
break;
}
break;
default: /* Invalid file ID */
error = -1;
}
return error;
}
*/
先来分析这个console_setfile函数,如果在初始化设备的时候,定义了输入输出设备的话,就调用device_t函数里面的start函数,来开启该设备,如果没有定义这些设备的话,通过stdio_devices[file] = dev根据console_init_r函数来指定标准输入,标准输出,标准错误设备,这个stdio_devices在common/devices.c中是这样定义的:device_t *stdio_devices[] = { NULL, NULL, NULL };可以看到他们没有指定这些设备,所以通过
console_setfile (stdout, outputdev);
console_setfile (stderr, outputdev);
console_setfile (stdin, inputdev);
这3句话就指定好标准输入,标准输出,标准错误设备,并且将标准输出和标准错误设备指定为同一个设备,这样就可以通过输出设备来输出错误信息了。 */
gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
/* 设置好这些设备以后,将gd_t结构体里面的flags添加GD_FLG_DEVINIT属性,表示设备的初始化已经完成。*/
#ifndef CFG_CONSOLE_INFO_QUIET
/* Print information */
puts ("In: ");
if (stdio_devices[stdin] == NULL) {
puts ("No input devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdin]->name);
}
puts ("Out: ");
if (stdio_devices[stdout] == NULL) {
puts ("No output devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdout]->name);
}
puts ("Err: ");
if (stdio_devices[stderr] == NULL) {
puts ("No error devices available!\n");
} else {
printf ("%s\n", stdio_devices[stderr]->name);
}
#endif /* CFG_CONSOLE_INFO_QUIET */
/* 将标准输入,标准输出,标准错误这些设备的信息打印出来。 */
/* Setting environment variables */
for (i = 0; i < 3; i++) {
setenv (stdio_names[i], stdio_devices[i]->name);
}
/* 将信息写到环境变量中去char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" }; */
return (0);
}
/* 这样就完成了console_init_r函数的分析。 */
(15)继续在start_armboot函数中执行:
/* enable exceptions */
enable_interrupts ();
/* 跟踪这个函数,同样是两个函数,如果定义CONFIG_USE_IRQ宏的话,就使用第一个,但是我们没有定义这个宏,使用第二个,第二个函数是一个空函数,所以忽略它。。。 */
/* Perform network card initialisation if necessary */
#ifdef CONFIG_DRIVER_CS8900
cs8900_get_enetaddr (gd->bd->bi_enetaddr);
#endif
/* 2410中定义了CONFIG_DRIVER_CS8900这个宏,但是我们用的是DM9000网卡,所以暂时先不分析这个函数。 */
/* Initialize from environment */
if ((s = getenv ("loadaddr")) != NULL) {
load_addr = simple_strtoul (s, NULL, 16);
}
#if (CONFIG_COMMANDS & CFG_CMD_NET)
if ((s = getenv ("bootfile")) != NULL) {
copy_filename (BootFile, s, sizeof (BootFile));
}
#endif /* CFG_CMD_NET */
#if (CONFIG_COMMANDS & CFG_CMD_NET)
#if defined(CONFIG_NET_MULTI)
puts ("Net: ");
#endif
eth_initialize(gd->bd);
#endif
/* 上面的函数看看就能理解了,基本也没做什么。。。 */
/* main_loop() can return to retry autoboot, if so just run it again. */
for (;;) {
main_loop ();
}
/* 到这,start_armboot函数就执行完了,可以看到,这个函数的最后是一个死循环,联想uboot的界面,可以理解,uboot一直在等待用户输入命令信息,然后解析这些命令,根据不用的命令来作出不用的操作。所以下面我们来分析这个main_loop()函数。 */
(16)main_loop()函数:
void main_loop (void)
{
#ifndef CFG_HUSH_PARSER
static char lastcommand[CFG_CBSIZE] = { 0, };
int len;
int rc = 1;
int flag;
#endif
#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
char *s;
int bootdelay;
#endif
#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
s = getenv ("bootdelay");
bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
/* 通过getenv函数,去环境变量中取bootdelay的值,如果存在的话,就采用环境变量中设置的值,如果不存在的话,就使用配置中的值CONFIG_BOOTDELAY。 */
debug ("### main_loop entered: bootdelay=%d\n\n", bootdelay);
s = getenv ("bootcmd"); /* 到环境变量中去取启动命令字符串。 */
debug
("### main_loop: bootcmd=\"%s\"\n", s ? s :
"
if (bootdelay >= 0 && s && !abortboot (bootdelay)) {
run_command (s, 0);
}
#endif /* CONFIG_BOOTDELAY */
/* 注意这个if语句,必须这三者同时满足条件的话才往下进行这个run_command()函数,否则跳出这个if语句,进入下面的for循环。其中用到了延时函数(abortboot),若在延时期间没有按下任何键的话,则返回0,经过!abortboot,变成1,这样函数就能继续往下执行。 */
/*
* Main Loop for Monitor Command Processing
*/
for (;;)
{
len = readline (CFG_PROMPT);
flag = 0; /* assume no special flags for now */
if (len > 0)
strcpy (lastcommand, console_buffer);
else if (len == 0)
flag |= CMD_FLAG_REPEAT;
if (len == -2)
{
/* -2 means timed out, retry autoboot
*/
puts ("\nTimed out waiting for command\n");
return; /* retry autoboot */
}
if (len == -1)
puts
("
else
rc = run_command (lastcommand, flag);
if (rc <= 0)
{
/* invalid command or not repeatable, forget it */
lastcommand[0] = 0;
}
}
}
/* 这个主循环中,重点是len = readline (CFG_PROMPT)函数,后面的程序都是解析这个len来分别作出不同的反应:
1> 如果readline函数返回0的话,说明输入了enter键,通过flag |= CMD_FLAG_REPEAT来添加属性,这个flags在后面作为run_command函数的一个参数。
2> 如果readline函数返回-1的话,说明按下了ctrl+c键,打印出"
3> 如果readline函数返回-2的话,说明超时了,打印出"\nTimed out waiting for command\n"这句话。
4> 如果readline函数返回值len>0的话,通过strcpy (lastcommand, console_buffer);把 console_buffer里面的值拷贝到 lastcommand中,最后执行run_command (lastcommand, flag)这个语句。
这个CFG_PROMPT在include/config/smdk2410.h中定义:
#define CFG_PROMPT "SMDK2410 # " /* Monitor Command Prompt */
下面来分析这个readline()函数:
int readline (const char *const prompt)
{
char *p = console_buffer;
int n = 0; /* buffer index */
int plen = 0; /* prompt length */
int col; /* output column cnt */
char c;
/* console_buffer在文件开头的定义如下:
char console_buffer[CFG_CBSIZE]; /* console I/O buffer */
#define CFG_CBSIZE 256 /* Console I/O Buffer Size */
所以这个数组实际上就是一个char类型的数组: console_buffer[256]。
*/
/* print prompt */
if (prompt) {
plen = strlen (prompt);
puts (prompt);
}
col = plen;
/* 先打印出来这个 prompt,在smdk2410.h我们定义它为"SMDK2410 # ",我们在使用uboot的时候,可以看到这个提示符,所以我们想要修改提示符的话,可以修改这个宏, */
for (;;) {
WATCHDOG_RESET(); /* Trigger watchdog, if needed */
c = getc();
/*
* Special character handling
*/
switch (c) {
case '\r': /* Enter */
case '\n':
*p = '\0';
puts ("\r\n");
return (p – console_buffer);
/* 判断输入了什么,如果输入enter的话,*p = '\0', p – console_buffer = 0,所以这个readline函数返回0。 */
case '\0': /* nul */
continue;
case 0x03: /* ^C – break */
console_buffer[0] = '\0'; /* discard input */
return (-1);
/* 输入ctrl+c的话,返回-1。 */
case 0x15: /* ^U - erase line */
while (col > plen) {
puts (erase_seq);
--col;
}
p = console_buffer;
n = 0;
continue;
case 0x17: /* ^W - erase word */
p=delete_char(console_buffer, p, &col, &n, plen);
while ((n > 0) && (*p != ' ')) {
p=delete_char(console_buffer, p, &col, &n, plen);
}
continue;
case 0x08: /* ^H - backspace */
case 0x7F: /* DEL – backspace */
p=delete_char(console_buffer, p, &col, &n, plen);
continue;
default:
/*
* Must be a normal character then
*/
if (n < CFG_CBSIZE-2) {
if (c == '\t') { /* expand TABs */
puts (tab_seq+(col&07));
col += 8 - (col&07);
} else {
++col; /* echo input */
putc (c);
}
*p++ = c;
++n;
} else { /* Buffer full */
putc ('\a');
}
}
}
}
可以看出来,这个main_loop函数的核心就是run_command函数,它根据输入的不同命令,来辨别不同的操作,最后执行这个操作,所以下面分析这个run_command函数。*/
(17) run_command函数分析和uboot中命令实现方式。
run_command函数位于common/main.c中:
int run_command (const char *cmd, int flag)
{
cmd_tbl_t *cmdtp;
char cmdbuf[CFG_CBSIZE]; /* working copy of cmd */
char *token; /* start of token in cmdbuf */
char *sep; /* end of token (separator) in cmdbuf */
char finaltoken[CFG_CBSIZE];
char *str = cmdbuf;
char *argv[CFG_MAXARGS + 1]; /* NULL terminated */
int argc, inquotes;
int repeatable = 1;
int rc = 0;
clear_ctrlc(); /* forget any previous Control C */
if (!cmd || !*cmd) {
return -1; /* empty command */
}
/* 空命令 */
if (strlen(cmd) >= CFG_CBSIZE) {
puts ("## Command too long!\n");
return -1;
}
/* 判断命令的长度是否过长。 */
strcpy (cmdbuf, cmd);
while (*str) {
/*
* Find separator, or string end
* Allow simple escape of ';' by writing "\;"
*/
for (inquotes = 0, sep = str; *sep; sep++) {
if ((*sep=='\'') &&
(*(sep-1) != '\\'))
inquotes=!inquotes;
if (!inquotes &&
(*sep == ';') && /* separator */
( sep != str) && /* past string start */
(*(sep-1) != '\\')) /* and NOT escaped */
break;
}
/* 对于多个命令的处理,uboot中允许用;隔开两个命令一起输入,这处理的就是这种情况。 */
/*
* Limit the token to data between separators
*/
token = str;
if (*sep) {
str = sep + 1; /* start of command for next pass */
*sep = '\0';
}
else
str = sep; /* no more commands for next pass */
/* find macros in this token and replace them */
process_macros (token, finaltoken);
/* 对宏的一些处理。 */
/* Extract arguments */
if ((argc = parse_line (finaltoken, argv)) == 0) {
rc = -1; /* no command at all */
continue;
}
/* 对命令的分析处理,一会在下面继续分析这个函数。 */
/* Look up command in command table */
if ((cmdtp = find_cmd(argv[0])) == NULL) {
printf ("Unknown command '%s' - try 'help'\n", argv[0]);
rc = -1; /* give up after bad command */
continue;
}
/* 寻找命令函数,从保存的命令中找到与输入命令所匹配的,同样,一会分析它。 */
/* found - check max args */
if (argc > cmdtp->maxargs) {
printf ("Usage:\n%s\n", cmdtp->usage);
rc = -1;
continue;
}
#if (CONFIG_COMMANDS & CFG_CMD_BOOTD)
/* avoid "bootd" recursion */
if (cmdtp->cmd == do_bootd) {
if (flag & CMD_FLAG_BOOTD) {
puts ("'bootd' recursion detected\n");
rc = -1;
continue;
} else {
flag |= CMD_FLAG_BOOTD;
}
}
#endif /* CFG_CMD_BOOTD */
/* run_command函数中传入的flags参数,与所定义的宏进行比对,然后执行相关的操作,这两个宏定义如下:#define CMD_FLAG_BOOTD 0x0002 /* command is from bootd */
*/
/* OK - call function to do the command */
if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) {
rc = -1;
}
repeatable &= cmdtp->repeatable;
/* Did the user stop this? */
if (had_ctrlc ())
return 0; /* if stopped then not repeatable */
}
return rc ? rc : repeatable;
}
在这里,有一个很重要的结构体,cmd_tbl_t,它贯穿了命令实现的始终,在include/command.h中定义:
struct cmd_tbl_s {
char *name; /* Command Name */
int maxargs; /* maximum number of arguments */
int repeatable; /* autorepeat allowed? */
/* Implementation function */
int (*cmd)(struct cmd_tbl_s *, int, int, char *[]);
char *usage; /* Usage message (short) */
char *help; /* Help message (long) */
};
typedef struct cmd_tbl_s cmd_tbl_t;
这个结构体里面包含命令的名字,最大参数数目,是否可重复,usage和help信息,以及一个执行函数。对于这个是否可重复性是指,在uboot等待用户输入状态下,直接敲回车键,自动执行刚执行过的上一条命令,这个在uboot的使用过程中应该可以发现。
可以分析这个run_command函数,大体过程是这样的:
1> 对输入的命令进行一些简单的处理。
2> 有一个while (*str)循环,在这个循环里面,首先对命令分析,看它是否是两个命令一起输入的。
3> 然后是对命令中的宏进行处理,通过这个process_macros函数。
4> 对命令中的参数进行分析,比如说有的命令只有一个参数,如help,有的命令有2个参数,比如bootm 30000000,对于这两种不同的情况,通过这个parse_line函数进行处理,将命令分别保存在argv[0],argv[1]....中。
5> 通过find_cmd函数来找到与输入命令所匹配的命令操作。
6> 最后通过cmdtp->cmd来调用操作函数。
下面来分析parse_line函数,它在common/main.c中:
int parse_line (char *line, char *argv[])
{
int nargs = 0;
while (nargs < CFG_MAXARGS) {
/* skip any white space */
while ((*line == ' ') || (*line == '\t')) {
++line;
} /* 跳过空格 */
if (*line == '\0') { /* end of line, no more args */
argv[nargs] = NULL;
return (nargs);
}
/* 如果为空命令的话,直接让这个函数返回0,并且argv[0]=NULL。 */
argv[nargs++] = line; /* begin of argument string */
/* find end of string */
while (*line && (*line != ' ') && (*line != '\t')) {
++line;
}
if (*line == '\0') { /* end of line, no more args */
argv[nargs] = NULL;
return (nargs);
}
/* 将line填写进argv[0],argv[1]...中,并且使最后一个argv[nargs]=NULL,最后返回argv[]的个数 nargs。 */
*line++ = '\0'; /* terminate current arg */
}
/* end of while (nargs < CFG_MAXARGS) */
printf ("** Too many args (max. %d) **\n", CFG_MAXARGS);
return (nargs);
}
这个parse_line的返回值为argv[]的个数,这样run_command函数就可以根据这些返回值进行操作了。
下面分析这个find_cmd函数:
这个函数同样在common/command.c中:
cmd_tbl_t *find_cmd (const char *cmd)
{
cmd_tbl_t *cmdtp;
cmd_tbl_t *cmdtp_temp = &__u_boot_cmd_start; /*Init value */
const char *p;
int len;
int n_found = 0;
/*
* Some commands allow length modifiers (like "cp.b");
* compare command name only until first dot.
*/
len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd);
for (cmdtp = &__u_boot_cmd_start;
cmdtp != &__u_boot_cmd_end;
cmdtp++) {
if (strncmp (cmd, cmdtp->name, len) == 0) {
if (len == strlen (cmdtp->name))
return cmdtp; /* full match */
cmdtp_temp = cmdtp; /* abbreviated command ? */
n_found++;
}
}
if (n_found == 1) { /* exactly one match */
return cmdtp_temp;
}
return NULL; /* not found or ambiguous command */
}
先大致浏览这个函数,它通过从__u_boot_cmd_start到__u_boot_cmd_end之间的区域去搜索匹配的命令,我们跟踪__u_boot_cmd_start的定义,可以在include/command.h中看到有这样的定义:
extern cmd_tbl_t __u_boot_cmd_start;
extern cmd_tbl_t __u_boot_cmd_end;
但是搜索完源码都没有发现这两个变量的定义,它们其实是在board/smdk2410/uboot.lds中定义的:
SECTIONS
{
. = 0x00000000;
. = ALIGN(4);
.text :
{
cpu/arm920t/start.o (.text)
*(.text)
}
. = ALIGN(4);
.rodata : { *(.rodata) }
. = ALIGN(4);
.data : { *(.data) }
. = ALIGN(4);
.got : { *(.got) }
. = .;
__u_boot_cmd_start = .;
.u_boot_cmd : { *(.u_boot_cmd) }
__u_boot_cmd_end = .;
. = ALIGN(4);
__bss_start = .;
.bss : { *(.bss) }
_end = .;
}
他们是怎么跑到链接脚本里面了?链接脚本中位于__u_boot_cmd_start和__u_boot_cmd_end之间是.u_boot_cmd段,那么这个段究竟里面是什么?我们在源码中搜索这个,可以发现如下的内容:
#define Struct_Section __attribute__ ((unused,section (".u_boot_cmd")))
以bootm 30000000为例,尽管搜索到了如上所示的内容,但是仍然没法知道调用了哪个函数,于是我们继续搜索bootm,在common/cmd_bootm.c中发现如下内容:
U_BOOT_CMD(
bootm, CFG_MAXARGS, 1, do_bootm,
"bootm - boot application image from memory\n",
"[addr [arg ...]]\n - boot application image stored in memory\n"
"\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
"\t'arg' can be the address of an initrd image\n"
#ifdef CONFIG_OF_FLAT_TREE
"\tWhen booting a Linux kernel which requires a flat device-tree\n"
"\ta third argument is required which is the address of the of the\n"
"\tdevice-tree blob. To boot that kernel without an initrd image,\n"
"\tuse a '-' for the second argument. If you do not pass a third\n"
"\ta bd_info struct will be passed instead\n"
#endif
);
继续搜索U_BOOT_CMD这个宏,可以在include/command.h中发现如下定义:
#define U_BOOT_CMD(name,maxargs,rep,cmd,usage,help) \
cmd_tbl_t __u_boot_cmd_##name Struct_Section = {#name, maxargs, rep, cmd, usage, help}
继续以bootm为例来分析这个宏,将U_BOOT_CMD宏的内容填充进去,其中##是连词符:
cmd_tbl_t __u_boot_cmd_bootm __attribute__ ((unused,section (".u_boot_cmd"))) = {bootm, CFG_MAXARGS, 1, do_bootm, usage, help}
usage = "bootm - boot application image from memory\n"
help = "[addr [arg ...]]\n - boot application image stored in memory\n"
"\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
"\t'arg' can be the address of an initrd image\n"
可以看出来,这个宏定义了一个cmd_tbl_t类型的变量__u_boot_cmd_bootm,这个变量带有一个属性__attribute__ ((unused,section (".u_boot_cmd"))),即将这个变量的段属性设置成.u_boot_cmd类型的,这样,所有的命令都以这种形式存在链接脚本指定的位置了。开始地址就是__u_boot_cmd_start,结束地址是__u_boot_cmd_end。所以,我们想要给uboot中添加啊一个命令的话,肯定也是构建这样的一个宏,宏里面包含命令的一些参数。
这样再返回来看这个find_cmd函数,就很好理解了。
run_command函数从find_cmd函数处继续执行,最后通过
(cmdtp->cmd) (cmdtp, flag, argc, argv)这个命令来执行与输入命令所匹配的函数。
至此,我们就分析完了run_command函数。
最后分析do_bootm函数。
do_bootm函数位于common/cmd_bootm.c中,在分析这个函数之前,我们先将image_header_t这个结构体分析一下,因为在这个do_bootm中会一直用到这个结构体中的变量,这个结构体位于include/image.h中,如下所示:
typedef struct image_header {
uint32_t ih_magic; /* Image Header Magic Number */
uint32_t ih_hcrc; /* Image Header CRC Checksum */
uint32_t ih_time; /* Image Creation Timestamp */
uint32_t ih_size; /* Image Data Size */
uint32_t ih_load; /* Data Load Address */
uint32_t ih_ep; /* Entry Point Address */
uint32_t ih_dcrc; /* Image Data CRC Checksum */
uint8_t ih_os; /* Operating System */
uint8_t ih_arch; /* CPU architecture */
uint8_t ih_type; /* Image Type */
uint8_t ih_comp; /* Compression Type */
uint8_t ih_name[IH_NMLEN]; /* Image Name */
} image_header_t;
简单分析一下他的成员, ih_magic是幻数, ih_hcrc是头信息校验, ih_load是加载地址,是Image所放的位置,我们比较关心这个成员, ih_ep是入口地址,也是我们关心的一个成员, ih_dcrc是数据校验, ih_os是 Operating System,即操作系统的类型,ih_arch是架构相关的信息, ih_type是 映像的类型。
下面继续分析do_bootm函数:
bootm这个命令用于启动一个操作系统映像,它会从映像文件的头部取得一些信息,这些信息包括:
映像文件的基于的cpu架构、其操作系统类型、映像的类型、压缩方式、映像文件在内存中的加载地址、
映像文件运行的入口地址、映像文件名等。
紧接着bootm将映像加载到指定的地址,如果需要的话,还会解压映像并传递必要有参数给内核,最后
跳到入口地址进入内核。
int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong iflag;
ulong addr;
ulong data, len, checksum;
ulong *len_ptr;
uint unc_len = CFG_BOOTM_LEN;
int i, verify;
char *name, *s;
int (*appl)(int, char *[]);
image_header_t *hdr = &header;
s = getenv ("verify");
verify = (s && (*s == 'n')) ? 0 : 1;
/* 从环境变量中获取"verify",最后这个信息需要传到do_bootm_linux函数中。 */
if (argc < 2) {
addr = load_addr;
} else {
addr = simple_strtoul(argv[1], NULL, 16);
}
/* 如果输入的命令的argc < 2的话,即直接输入bootm命令,此时映像存储地址使用默认的load_addr:
ulong load_addr = CFG_LOAD_ADDR; /* Default Load Address */
#define CFG_LOAD_ADDR 0x33000000 /* default load address */
在前面是这样定义的,有一个默认的映像存储地址。但是在uboot运行期间,load_addr的值会被环境变量所更改。如果bootm后面还带有一个参数,如bootm 30000000,将这个30000000存到addr中。 */
SHOW_BOOT_PROGRESS (1);
printf ("## Booting image at %08lx ...\n", addr);
/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
read_dataflash(addr, sizeof(image_header_t), (char *)&header);
} else
#endif
/* 上面这个宏没有定义,所以不会执行。 */
memmove (&header, (char *)addr, sizeof(image_header_t));
/* 将我们输入的这个addr的值存到header中,这样就可以使用这个hdr了。 */
if (ntohl(hdr->ih_magic) != IH_MAGIC) {
{
puts ("Bad Magic Number\n");
SHOW_BOOT_PROGRESS (-1);
return 1;
}
}
SHOW_BOOT_PROGRESS (2);
/* 如果hdr里面的ih_magic不等于预定义的幻数的话,就打印出“Bad Magic Number”并返回。
#define IH_MAGIC 0x27051956 /* Image Magic Number */
*/
data = (ulong)&header;
len = sizeof(image_header_t);
/* 现在这个data里面保存的就是我们所输入的这个addr地址。len是image_header_t 结构体的长度。 */
checksum = ntohl(hdr->ih_hcrc);
hdr->ih_hcrc = 0;
if (crc32 (0, (uchar *)data, len) != checksum) {
puts ("Bad Header Checksum\n");
SHOW_BOOT_PROGRESS (-2);
return 1;
}
SHOW_BOOT_PROGRESS (3);
/* hdr->ih_hcrc里面保存的是头信息校验信息,用crc32校验它是否正确。 */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
len = ntohl(hdr->ih_size) + sizeof(image_header_t);
read_dataflash(addr, len, (char *)CFG_LOAD_ADDR);
addr = CFG_LOAD_ADDR;
}
#endif
/* 没有定义这个宏,不会执行。 */
/* for multi-file images we need the data part, too */
print_image_hdr ((image_header_t *)addr);
/* 打印出一些信息,如Image类型,创建时间,加载地址等。 */
data = addr + sizeof(image_header_t);
len = ntohl(hdr->ih_size);
if (verify) {
puts (" Verifying Checksum ... ");
if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
printf ("Bad Data CRC\n");
SHOW_BOOT_PROGRESS (-3);
return 1;
}
puts ("OK\n");
}
SHOW_BOOT_PROGRESS (4);
len_ptr = (ulong *)data;
#if defined(__PPC__)
if (hdr->ih_arch != IH_CPU_PPC)
#elif defined(__ARM__)
if (hdr->ih_arch != IH_CPU_ARM)
#elif defined(__I386__)
if (hdr->ih_arch != IH_CPU_I386)
#elif defined(__mips__)
if (hdr->ih_arch != IH_CPU_MIPS)
#elif defined(__nios__)
if (hdr->ih_arch != IH_CPU_NIOS)
#elif defined(__M68K__)
if (hdr->ih_arch != IH_CPU_M68K)
#elif defined(__microblaze__)
if (hdr->ih_arch != IH_CPU_MICROBLAZE)
#elif defined(__nios2__)
if (hdr->ih_arch != IH_CPU_NIOS2)
#elif defined(__blackfin__)
if (hdr->ih_arch != IH_CPU_BLACKFIN)
#elif defined(__avr32__)
if (hdr->ih_arch != IH_CPU_AVR32)
#else
# error Unknown CPU type
#endif
{
printf ("Unsupported Architecture 0x%x\n", hdr->ih_arch);
SHOW_BOOT_PROGRESS (-4);
return 1;
}
SHOW_BOOT_PROGRESS (5);
/* 上面这一段代码没看懂想要检查什么,这些宏都没有定义。 */
switch (hdr->ih_type) {
case IH_TYPE_STANDALONE:
name = "Standalone Application";
/* A second argument overwrites the load address */
if (argc > 2) {
hdr->ih_load = htonl(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);
/* hdr->ih_type里面保存的是映像的类型,这里是先检查映像的类型,有kernel,ramdisk,multi,firmware等类型,根据不同的类型来获得真正的Image data(即不包括头信息的image)的起始地址(data)和大小(len)。 */
/*
* 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(); /* 关中断 */
#ifdef CONFIG_AMIGAONEG3SE
/*
* We've possible left the caches enabled during
* bios emulation, so turn them off again
*/
icache_disable();
invalidate_l1_instruction_cache();
flush_data_cache();
dcache_disable();
#endif
/* 未定义的宏,不会执行。 */
switch (hdr->ih_comp) {
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:
printf (" Uncompressing %s ... ", name);
if (gunzip ((void *)ntohl(hdr->ih_load), unc_len,
(uchar *)data, &len) != 0) {
puts ("GUNZIP ERROR - must RESET board to recover\n");
SHOW_BOOT_PROGRESS (-6);
do_reset (cmdtp, flag, argc, argv);
}
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 */
default:
if (iflag)
enable_interrupts();
printf ("Unimplemented compression type %d\n", hdr->ih_comp);
SHOW_BOOT_PROGRESS (-7);
return 1;
}
puts ("OK\n");
SHOW_BOOT_PROGRESS (7);
/* hdr->ih_comp里面保存的是image的压缩方式,IH_COMP_NONE 表示未压缩的image,IH_COMP_GZIP 表示gzip的压缩方式,IH_COMP_BZIP2 表示gzip2的压缩方式,根据压缩方式来选择将要执行的动作,对于 IH_COMP_NONE类型的,判断它的加载地址是否与它头信息里面的加载地址相同,如果相同打印出"XIP %s ... ",如果不同,则调用 memmove函数,将image移动到头信息执行的加载地址。 */
switch (hdr->ih_type) {
case IH_TYPE_STANDALONE:
if (iflag)
enable_interrupts();
/* load (and uncompress), but don't start if "autostart"
* is set to "no"
*/
if (((s = getenv("autostart")) != NULL) && (strcmp(s,"no") == 0)) {
char buf[32];
sprintf(buf, "%lX", len);
setenv("filesize", buf);
return 0;
}
appl = (int (*)(int, char *[]))ntohl(hdr->ih_ep);
(*appl)(argc-1, &argv[1]);
return 0;
case IH_TYPE_KERNEL:
case IH_TYPE_MULTI:
/* handled below */
break;
default:
if (iflag)
enable_interrupts();
printf ("Can't boot image type %d\n", hdr->ih_type);
SHOW_BOOT_PROGRESS (-8);
return 1;
}
SHOW_BOOT_PROGRESS (8);
/* hdr->ih_type里面保存的是映像的类型,在前面已经设置过一部分内容,现在这里再设置一些内容。 */
switch (hdr->ih_os) {
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;
case IH_OS_NETBSD:
do_bootm_netbsd (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
#ifdef CONFIG_LYNXKDI
case IH_OS_LYNXOS:
do_bootm_lynxkdi (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
#endif
case IH_OS_RTEMS:
do_bootm_rtems (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
#if (CONFIG_COMMANDS & CFG_CMD_ELF)
case IH_OS_VXWORKS:
do_bootm_vxworks (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
case IH_OS_QNX:
do_bootm_qnxelf (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
#endif /* CFG_CMD_ELF */
#ifdef CONFIG_ARTOS
case IH_OS_ARTOS:
do_bootm_artos (cmdtp, flag, argc, argv,
addr, len_ptr, verify);
break;
#endif
}
SHOW_BOOT_PROGRESS (-9);
#ifdef DEBUG
puts ("\n## Control returned to monitor - resetting...\n");
do_reset (cmdtp, flag, argc, argv);
#endif
return 1;
}
/* hdr->ih_os里面保存的是操作系统的类型,根据不同的操作系统类型进去不同的入口中,对于linux,就进入了相应的do_bootm_linux函数中。 */
下面进入这个do_bootm_linux函数中,注意这个函数在很多文件里面都有定义,它是架构相关的,我们需要进入的是lib_arm/armlinux.c中的这个:
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
ulong addr, ulong *len_ptr, int verify)
{
ulong len = 0, checksum;
ulong initrd_start, initrd_end;
ulong data;
void (*theKernel)(int zero, int arch, uint params);
image_header_t *hdr = &header;
bd_t *bd = gd->bd;
#ifdef CONFIG_CMDLINE_TAG
char *commandline = getenv ("bootargs");
#endif
theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep);
/* 将这个函数指针指向入口地址。 */
/*
* Check if there is an initrd image
*/
if (argc >= 3) {
SHOW_BOOT_PROGRESS (9);
addr = simple_strtoul (argv[2], NULL, 16);
printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash (addr)) {
read_dataflash (addr, sizeof (image_header_t),
(char *) &header);
} else
#endif
memcpy (&header, (char *) addr, sizeof (image_header_t));
if (ntohl (hdr->ih_magic) != IH_MAGIC) {
printf ("Bad Magic Number\n");
SHOW_BOOT_PROGRESS (-10);
do_reset (cmdtp, flag, argc, argv);
}
/* 检验 bootargs里面是否有initrd的信息,如果有的话,对这些信息进行处理。 */
data = (ulong) & header;
len = sizeof (image_header_t);
checksum = ntohl (hdr->ih_hcrc);
hdr->ih_hcrc = 0;
if (crc32 (0, (unsigned char *) data, len) != checksum) {
printf ("Bad Header Checksum\n");
SHOW_BOOT_PROGRESS (-11);
do_reset (cmdtp, flag, argc, argv);
}
SHOW_BOOT_PROGRESS (10);
print_image_hdr (hdr);
data = addr + sizeof (image_header_t);
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
/* 再次做一些检验等信息。。。之前在do_bootm中做过一些。 */
if (verify) {
ulong csum = 0;
printf (" Verifying Checksum ... ");
csum = crc32 (0, (unsigned char *) data, len);
if (csum != ntohl (hdr->ih_dcrc)) {
printf ("Bad Data CRC\n");
SHOW_BOOT_PROGRESS (-12);
do_reset (cmdtp, flag, argc, argv);
}
printf ("OK\n");
}
SHOW_BOOT_PROGRESS (11);
if ((hdr->ih_os != IH_OS_LINUX) ||
(hdr->ih_arch != IH_CPU_ARM) ||
(hdr->ih_type != IH_TYPE_RAMDISK)) {
printf ("No Linux ARM Ramdisk Image\n");
SHOW_BOOT_PROGRESS (-13);
do_reset (cmdtp, flag, argc, argv);
}
#if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO)
/*
*we need to copy the ramdisk to SRAM to let Linux boot
*/
memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
data = ntohl(hdr->ih_load);
#endif /* CONFIG_B2 || CONFIG_EVB4510 */
/* 没有定义这些宏,不会执行。 */
/*
* Now check if we have a multifile image
*/
} /* end if (argc >= 3) */
else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
ulong tail = ntohl (len_ptr[0]) % 4;
int i;
SHOW_BOOT_PROGRESS (13);
/* skip kernel length and terminator */
data = (ulong) (&len_ptr[2]);
/* skip any additional image length fields */
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
data += ntohl (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
len = ntohl (len_ptr[1]);
} else {
/*
* no initrd image
*/
SHOW_BOOT_PROGRESS (14);
len = data = 0;
}
#ifdef DEBUG
if (!data) {
printf ("No initrd\n");
}
#endif
if (data) {
initrd_start = data;
initrd_end = initrd_start + len;
} else {
initrd_start = 0;
initrd_end = 0;
}
SHOW_BOOT_PROGRESS (15);
debug ("## Transferring control to Linux (at address %08lx) ...\n",
(ulong) theKernel);
#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
defined (CONFIG_CMDLINE_TAG) || \
defined (CONFIG_INITRD_TAG) || \
defined (CONFIG_SERIAL_TAG) || \
defined (CONFIG_REVISION_TAG) || \
defined (CONFIG_LCD) || \
defined (CONFIG_VFD)
setup_start_tag (bd);
#ifdef CONFIG_SERIAL_TAG
setup_serial_tag (¶ms);
#endif
#ifdef CONFIG_REVISION_TAG
setup_revision_tag (¶ms);
#endif
#ifdef CONFIG_SETUP_MEMORY_TAGS
setup_memory_tags (bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
setup_commandline_tag (bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
if (initrd_start && initrd_end)
setup_initrd_tag (bd, initrd_start, initrd_end);
#endif
#if defined (CONFIG_VFD) || defined (CONFIG_LCD)
setup_videolfb_tag ((gd_t *) gd);
#endif
setup_end_tag (bd);
#endif
/* 上面就是设置taglist,这些参数是要传给内核的,关于这些tag的设置,在自己写bootloader中写的很清楚了,在这就不写了。 */
/* we assume that the kernel is in place */
printf ("\nStarting kernel ...\n\n");
#ifdef CONFIG_USB_DEVICE
{
extern void udc_disconnect (void);
udc_disconnect ();
}
#endif
cleanup_before_linux ();
/* 进入内核前,需要关中断,关i/d-cache。 */
theKernel (0, bd->bi_arch_number, bd->bi_boot_params);
}
在这个函数中,重要的就是为内核执行入口地址,设置taglist,最后调用这个theKernel函数,我在程序中用黄色背景标出了。这样,就可以启动内核了。