U-boot启动详解cpu/arm920t/start.S
/* ************************************************************************* * * Jump vector table as in table 3.1 in [1] * ************************************************************************* */ ;定义变量_start，然后跳转到处理器复位代码
.globl _start _start: b reset ;产生中断则利用pc来跳转到对应的中断处理程序中 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 ;利用.word来在当前位置放置一个值，这个值实际上就用对应的中断处理函数的地址 ;.word的意义为在当前地址处放入一个16bits值 _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 #ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */ .globl IRQ_STACK_START IRQ_STACK_START: .word 0x0badc0de /* IRQ stack memory (calculated at run-time) */
.globl FIQ_STACK_START FIQ_STACK_START: .word 0x0badc0de #endif /* * the actual reset code */ ;实际处理代码 reset: /* * set the cpu to SVC32 mode */ mrs r0,cpsr ;bic清除指定为1的位 bic r0,r0,#0x1f ;orr逻辑或操作 orr r0,r0,#0xd3 ;经过以上两步r0值控制位位11010011，第0～4位标识处理器当前所处模式为10011(32位管理模式)，第6、7位 ;为1标识禁止IRQ和FIQ中断，第5位为0标识程序运行为arm状态，若其为1则运行在thumb状态 ;设置处理器为32位管理模式，并运行与arm状态 msr cpsr,r0 /* 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 ;中断掩码寄存器，决定那个中断源被屏蔽，某位为1则屏蔽中断源，初始值为0xFFFFFFFF，屏蔽所有中断 # define INTMSK 0x4A000008 /* Interupt-Controller base addresses */ ;中断子掩码寄存器，该寄存器只能屏蔽11个中断源，因此其仅低11位有效，初始值为0x7FF # define INTSUBMSK 0x4A00001C ;时钟分频控制寄存器 # define CLKDIVN 0x4C000014 /* clock divisor register */ #endif #if defined(CONFIG_S3C2400) || defined(CONFIG_S3C2410)
;将看门狗寄存器清空，其各位含义为，第0位为1则当看门狗定时器溢出时重启，为0则不重启，初值为1 ;第2位为中断使能位，初值为0 ;第3、4位为时钟分频因子，初值为00， ;第5位为看门狗的使能位初值为1 ;第8～15位为比例因子，初值为0x80 ldr r0, =pWTCON mov r1, #0x0 ;将看门狗寄存器所有位置零，关闭看门狗，其实只要将第5位置0即可 str r1, [r0] ;屏蔽所有中断，实际上中断屏蔽掩码寄存器初值即为0xFFFFFFF mov r1, #0xffffffff ldr r0, =INTMSK str r1, [r0] # if defined(CONFIG_S3C2410) ;设置子中断掩码寄存器 ldr r1, =0x3ff ldr r0, =INTSUBMSK str r1, [r0] # endif ;设置时钟寄存器，CLKDIVN第0位为PDIVN，为0则PCLK=HCLK，为1则PCLK=HCLK/2 ;第1位为HDIVN，为0则HCLK=FCLK,为1则HCLK=FCLK/2 ;这里两位均为1，则FCLK:HCLK:PCLK = 4:2:1 /* 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! */ ;对临界寄存器的初始化，如果从ram中启动则不执行，如果重启则执行 #ifndef CONFIG_SKIP_LOWLEVEL_INIT bl cpu_init_crit #endif ;重定向代码，也就是从flash中复制到ram中 #ifndef CONFIG_SKIP_RELOCATE_UBOOT relocate: /* relocate U-Boot to RAM */ ;当前代码地址，adr获取当前代码的地址信息，若从ram运行则_start=TEXT_BASE,否则_start=0x00000000 adr r0, _start /* r0 <- current position of code */ ;获取_TEXT_BASE ldr r1, _TEXT_BASE /* test if we run from flash or RAM */ cmp r0, r1 /* don't reloc during debug */ ;两者相等，表示从ram运行则跳转到堆栈设置 beq stack_setup ;不相等则表示从flash中运行，重定向代码 ldr r2, _armboot_start ;获取未初始化数据段地址 ldr r3, _bss_start ;计算代码段大小 sub r2, r3, r2 /* r2 <- size of armboot */ ;计算代码段终止地址 add r2, r0, r2 /* r2 <- source end address */ ;复制代码，r0为代码的起始地址，r1为ram中地址，r2为代码的终止地址 ;每次copy后将r0值递增同r2比较来判断是否复制完成 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: ;获取_TEXT_BASE ldr r0, _TEXT_BASE /* upper 128 KiB: relocated uboot */ ;获取分配区域起始指针，CFG_MALLOC_LEN=128*1024+CFG_ENV_SIZE=128*1024+0x10000=192K sub r0, r0, #CFG_MALLOC_LEN /* malloc area */ ;另外分配128bytes来存储开发板信息 sub r0, r0, #CFG_GBL_DATA_SIZE /* bdinfo */ #ifdef CONFIG_USE_IRQ sub r0, r0, #(CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ) #endif ;再减去12bytes用于栈起点 sub sp, r0, #12 /* leave 3 words for abort-stack */ ;清空未初始化数据段 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 #if 0
;关闭看门狗 /* try doing this stuff after the relocation */ ldr r0, =pWTCON mov r1, #0x0 str r1, [r0] /*
* mask all IRQs by setting all bits in the INTMR - default */ ;禁止中断 mov r1, #0xffffffff ldr r0, =INTMR str r1, [r0] ;设置时钟 /* FCLK:HCLK:PCLK = 1:2:4 */ /* default FCLK is 120 MHz ! */ ldr r0, =CLKDIVN mov r1, #3 str r1, [r0] /* END stuff after relocation */ #endif ;完成复制后跳转到start_armboot,到这里就进入函数lib_arm/board.c的start_armboot函数中 ldr pc, _start_armboot _start_armboot: .word start_armboot
; 这里指的从flash中运行是指的从flash rom中运行，也就是常说的从nor flash中运行程序，现在有很多开发板;都是利用SDRAM和NAND-FLASH共同工作，所以需要添加从nand flash启动的代码。在ldr pc,_start_armboot前;;添加如下代码： #ifdef CONFIG_S3C2410_NAND_BOOT bl copy_myself @ jump to ram ldr r1, =on_the_ram add pc, r1, #0 nop nop 1: b 1b @ infinite loop on_the_ram: #endif ;开始就跳转到函数copy_myself中，
#ifdef CONFIG_S3C2410_NAND_BOOT copy_myself: ;保存断点地址 mov r10, lr @ reset NAND ;NAND_CTRL_BASE为nand flash的寄存器基址为0x4E000000 ;根据flash手册来复位flash mov r1, #NAND_CTL_BASE ;通过nand flash配置寄存器配置nand flash，该寄存器仅低16位有效 ;第15位为nand flash控制器使能位，第12位为初始化ECC使能位，第11位为nand falsh memory nFCE使能 ldr r2, =0xf830 @ initial value str r2, [r1, #oNFCONF] ldr r2, [r1, #oNFCONF] ;将第11位清零，使能芯片 bic r2, r2, #0x800 @ enable chip str r2, [r1, #oNFCONF] ;写入命令 mov r2, #0xff @ RESET command strb r2, [r1, #oNFCMD] ;循环延时 mov r3, #0 @ wait 1: add r3, r3, #0x1 cmp r3, #0xa blt 1b ;利用状态寄存器测试flash内部操作是否完成，如果完成则其状态寄存器将返回1 ;等待flash操作完成 2: ldr r2, [r1, #oNFSTAT] @ wait ready tst r2, #0x1 beq 2b ;禁止芯片 ldr r2, [r1, #oNFCONF] orr r2, r2, #0x800 @ disable chip str r2, [r1, #oNFCONF] @ get read to call C functions (for nand_read())
;建立堆栈，栈起点为0x33f00000，大小为0x8000 ldr sp, DW_STACK_START @ setup stack pointer mov fp, #0 @ no previous frame, so fp=0 @ copy U-BOOT to RAM
;UBOOT_RAM_BASE应该同TEXT_BASE相同 ldr r0, =UBOOT_RAM_BASE mov r1, #0x0 @address mov r2, #0x30000 @size ;这里设置大小为192K，为什么取这个值？为什么这三个寄存器的值就作为参数传递进去了？ ;跳转到board/smdk2410/nand_read.c中的nand_read_ll函数，代码见后面 ;该函数需要三个参数，r0为其在ram中的起始地址，r1为在源地址也就是flash中的起始地址，r2为需要 ;复制的中大小 bl nand_read_ll tst r0, #0x0 ;r0为返回值 ;如果成功完成复制则跳转到ok_nand_read beq ok_nand_read #ifdef CONFIG_DEBUG_LL
bad_nand_read: ldr r0, STR_FAIL ldr r1, SerBase bl PrintWord 1: b 1b @ infinite loop #endif ;打印信息 ok_nand_read: #ifdef CONFIG_DEBUG_LL ldr r0, STR_OK ldr r1, SerBase bl PrintWord #endif ;校验,因为从nand flash启动只需要将bootloader的前4K代码复制到stepping stone处即可 @ verify mov r0, #0 ldr r1, =UBOOT_RAM_BASE mov r2, #0x400 @ 4 bytes * 1024 = 4K-bytes go_next: ldr r3, [r0], #4 ldr r4, [r1], #4 teq r3, r4 bne notmatch subs r2, r2, #4 beq done_nand_read bne go_next notmatch:
#ifdef CONFIG_DEBUG_LL sub r0, r0, #4 ldr r1, SerBase bl PrintHexWord ldr r0, STR_FAIL ldr r1, SerBase bl PrintWord #endif 1: b 1b done_nand_read:
#ifdef CONFIG_DEBUG_LL ldr r0, STR_OK ldr r1, SerBase bl PrintWord #endif ;恢复断点，程序继续运行 mov pc, r10 ;内存清零???
@ clear memory @ r0: start address @ r1: length mem_clear: mov r2, #0 mov r3, r2 mov r4, r2 mov r5, r2 mov r6, r2 mov r7, r2 mov r8, r2 mov r9, r2 clear_loop: stmia r0!, {r2-r9} subs r1, r1, #(8 * 4) bne clear_loop mov pc, lr #endif @ CONFIG_S3C2410_NAND_BOOT
/* ************************************************************************* * * CPU_init_critical registers * * setup important registers * setup memory timing * ************************************************************************* */ ;对临界寄存器的初始化
#ifndef CONFIG_SKIP_LOWLEVEL_INIT cpu_init_crit: /* * flush v4 I/D caches */ ;清空指令和数据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 */ /*
* 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 /*
* 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. */ ;在重定向代码之前，必须初始化内存时序，因为重定向时需要将flash中的代码复制到内存中 ;内存初始化的代码在开发板目录下 mov ip, lr bl lowlevel_init mov lr, ip mov pc, lr #endif /* CONFIG_SKIP_LOWLEVEL_INIT */ /*
************************************************************************* * * Interrupt handling * ************************************************************************* */ ;中断处理 @ @ IRQ stack frame. @ #define S_FRAME_SIZE 72 #define S_OLD_R0 68
#define S_PSR 64 #define S_PC 60 #define S_LR 56 #define S_SP 52 #define S_IP 48
#define S_FP 44 #define S_R10 40 #define S_R9 36 #define S_R8 32 #define S_R7 28 #define S_R6 24 #define S_R5 20 #define S_R4 16 #define S_R3 12 #define S_R2 8 #define S_R1 4 #define S_R0 0 #define MODE_SVC 0x13
#define I_BIT 0x80 /*
* use bad_save_user_regs for abort/prefetch/undef/swi ... * use irq_save_user_regs / irq_restore_user_regs for IRQ/FIQ handling */ .macro bad_save_user_regs
sub sp, sp, #S_FRAME_SIZE stmia sp, {r0 - r12} @ Calling r0-r12 ldr r2, _armboot_start sub r2, r2, #(CONFIG_STACKSIZE+CFG_MALLOC_LEN) sub r2, r2, #(CFG_GBL_DATA_SIZE+8) @ set base 2 words into abort stack ldmia r2, {r2 - r3} @ get pc, cpsr add r0, sp, #S_FRAME_SIZE @ restore sp_SVC add r5, sp, #S_SP
mov r1, lr stmia r5, {r0 - r3} @ save sp_SVC, lr_SVC, pc, cpsr mov r0, sp .endm .macro irq_save_user_regs
sub sp, sp, #S_FRAME_SIZE stmia sp, {r0 - r12} @ Calling r0-r12 add r8, sp, #S_PC stmdb r8, {sp, lr}^ @ Calling SP, LR str lr, [r8, #0] @ Save calling PC mrs r6, spsr str r6, [r8, #4] @ Save CPSR str r0, [r8, #8] @ Save OLD_R0 mov r0, sp .endm .macro irq_restore_user_regs
ldmia sp, {r0 - lr}^ @ Calling r0 - lr mov r0, r0 ldr lr, [sp, #S_PC] @ Get PC add sp, sp, #S_FRAME_SIZE subs pc, lr, #4 @ return & move spsr_svc into cpsr .endm .macro get_bad_stack
ldr r13, _armboot_start @ setup our mode stack sub r13, r13, #(CONFIG_STACKSIZE+CFG_MALLOC_LEN) sub r13, r13, #(CFG_GBL_DATA_SIZE+8) @ reserved a couple spots in abort stack str lr, [r13] @ save caller lr / spsr
mrs lr, spsr str lr, [r13, #4] mov r13, #MODE_SVC @ prepare SVC-Mode
@ msr spsr_c, r13 msr spsr, r13 mov lr, pc movs pc, lr .endm .macro get_irq_stack @ setup IRQ stack
ldr sp, IRQ_STACK_START .endm .macro get_fiq_stack @ setup FIQ stack
ldr sp, FIQ_STACK_START .endm /*
* exception handlers */ .align 5 undefined_instruction: get_bad_stack bad_save_user_regs bl do_undefined_instruction .align 5
software_interrupt: get_bad_stack bad_save_user_regs bl do_software_interrupt .align 5
prefetch_abort: get_bad_stack bad_save_user_regs bl do_prefetch_abort .align 5
data_abort: get_bad_stack bad_save_user_regs bl do_data_abort .align 5
not_used: get_bad_stack bad_save_user_regs bl do_not_used #ifdef CONFIG_USE_IRQ
.align 5
irq: get_irq_stack irq_save_user_regs bl do_irq irq_restore_user_regs .align 5
fiq: get_fiq_stack /* someone ought to write a more effiction fiq_save_user_regs */ irq_save_user_regs bl do_fiq irq_restore_user_regs #else
.align 5
irq: get_bad_stack bad_save_user_regs bl do_irq .align 5
fiq: get_bad_stack bad_save_user_regs bl do_fiq #endif
#ifdef CONFIG_S3C2410_NAND_BOOT .align 2 DW_STACK_START: .word STACK_BASE+STACK_SIZE-4 #endif //该函数来自于board/smdk2410/nand_read.c //通过r0，r1，r2三个寄存器传递参数过来，返回值为r0 int nand_read_ll(unsigned char *buf, unsigned long start_addr, int size) { int i, j; if ((start_addr & NAND_BLOCK_MASK) || (size & NAND_BLOCK_MASK)) {
return -1; /* invalid alignment */ } //按照芯片的时序来进行读写操作 /* chip Enable */ NFCONF &= ~0x800; for(i=0; i<10; i++); for(i=start_addr; i < (start_addr + size);) {
/* READ0 */ NFCMD = 0; /* Write Address */
NFADDR = i & 0xff; NFADDR = (i >> 9) & 0xff; NFADDR = (i >> 17) & 0xff; NFADDR = (i >> 25) & 0xff; wait_idle();
for(j=0; j < NAND_SECTOR_SIZE; j++, i++) {
*buf = (NFDATA & 0xff); buf++; } } /* chip Disable */
NFCONF |= 0x800; /* chip disable */ return 0;
} board/qt2410/lowlevel_init.S
;总线宽度和等待寄存器 #define BWSCON 0x48000000 ;宽度8bits、16bits、32bits /* BWSCON */ #define DW8 (0x0) #define DW16 (0x1) #define DW32 (0x2) ;等待 #define WAIT (0x1<<2) ;UBLB标识引脚信号的类型，为0则为nWBE，为1则为nBE #define UBLB (0x1<<3) ;定义总线类型 #define B1_BWSCON (DW32) #define B2_BWSCON (DW16) #define B3_BWSCON (DW16 + WAIT + UBLB) #define B4_BWSCON (DW16)1 #define B5_BWSCON (DW16) #define B6_BWSCON (DW32) #define B7_BWSCON (DW32) ;bank0寄存器 /* BANK0CON */ #define B0_Tacs 0x0 /* 0clk */ #define B0_Tcos 0x0 /* 0clk */ #define B0_Tacc 0x7 /* 14clk */ #define B0_Tcoh 0x0 /* 0clk */ #define B0_Tah 0x0 /* 0clk */ #define B0_Tacp 0x0 #define B0_PMC 0x0 /* normal */ ;bank1寄存器 /* BANK1CON */ #define B1_Tacs 0x0 /* 0clk */ #define B1_Tcos 0x0 /* 0clk */ #define B1_Tacc 0x7 /* 14clk */ #define B1_Tcoh 0x0 /* 0clk */ #define B1_Tah 0x0 /* 0clk */ #define B1_Tacp 0x0 #define B1_PMC 0x0 ;bank2寄存器 #define B2_Tacs 0x0 #define B2_Tcos 0x0 #define B2_Tacc 0x7 #define B2_Tcoh 0x0 #define B2_Tah 0x0 #define B2_Tacp 0x0 #define B2_PMC 0x0 ;bank3寄存器 #define B3_Tacs 0x0 /* 0clk */ #define B3_Tcos 0x3 /* 4clk */ #define B3_Tacc 0x7 /* 14clk */ #define B3_Tcoh 0x1 /* 1clk */ #define B3_Tah 0x0 /* 0clk */ #define B3_Tacp 0x3 /* 6clk */ #define B3_PMC 0x0 /* normal */ ;bank4寄存器 #define B4_Tacs 0x0 /* 0clk */ #define B4_Tcos 0x0 /* 0clk */ #define B4_Tacc 0x7 /* 14clk */ #define B4_Tcoh 0x0 /* 0clk */ #define B4_Tah 0x0 /* 0clk */ #define B4_Tacp 0x0 #define B4_PMC 0x0 /* normal */ ;bank5寄存器 #define B5_Tacs 0x0 /* 0clk */ #define B5_Tcos 0x0 /* 0clk */ #define B5_Tacc 0x7 /* 14clk */ #define B5_Tcoh 0x0 /* 0clk */ #define B5_Tah 0x0 /* 0clk */ #define B5_Tacp 0x0 #define B5_PMC 0x0 /* normal */ ;bank6寄存器 #define B6_MT 0x3 /* SDRAM */ #define B6_Trcd 0x1 #define B6_SCAN 0x1 /* 9bit */ ;bank7寄存器 #define B7_MT 0x3 /* SDRAM */ #define B7_Trcd 0x1 /* 3clk */ #define B7_SCAN 0x1 /* 9bit */ /* REFRESH parameter */
#define REFEN 0x1 /* Refresh enable */ #define TREFMD 0x0 /* CBR(CAS before RAS)/Auto refresh */ #define Trp 0x0 /* 2clk */ #define Trc 0x3 /* 7clk */ #define Tchr 0x2 /* 3clk */ #define REFCNT 1113 /* period=15.6us, HCLK=60Mhz, (2048+1-15.6*60) */ /**************************************/ _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 /*added by kyle*/ lmov r3,pc lldr r4,=0x3FFF0000 land r3,r3,r4 laad r0,r0,r3 ladd r2,r2,r3 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 ;定义函数指针 typedef int (init_fnc_t) (void); ;定义函数指针数组，对硬件初始化按照该数组进行 init_fnc_t *init_sequence[] = { cpu_init, //cpu/arm920t/cpu.c中定义，该函数为空，因为没有采用IRQ或FIQ模式 board_init, //board/smdk2410/smdk2410.c interrupt_init, //cpu/arm920t/s3c24x0/interrupt.c env_init, //tools/env/FW_env.c init_baudrate, //lib_arm/board.c serial_init, //cpu/arm920t/s3c24x0/serial.c console_init_f, //common/console.c display_banner, //lib_arm/board.c #if defined(CONFIG_DISPLAY_CPUINFO) print_cpuinfo, // #endif #if defined(CONFIG_DISPLAY_BOARDINFO) checkboard, // #endif dram_init, //board/smdk2410/smdk2410.c display_dram_config,//lib_arm/board.c NULL, }; int board_init (void) { ;将时间相关的寄存器定义为结构体S3C24X0_CLOCK_POWER，S3C24X0_GPIO也是一样 S3C24X0_CLOCK_POWER * const clk_power = S3C24X0_GetBase_CLOCK_POWER(); S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO(); ;设置cpu时钟 /* to reduce PLL lock time, adjust the LOCKTIME register */ clk_power->LOCKTIME = 0xFFFFFF; /* configure MPLL */
//M_MDIV=0xA1,M_PDIV=0x3,M_SDIV=0x1 //这样系统时钟为202.80M clk_power->MPLLCON = ((M_MDIV << 12) + (M_PDIV << 4) + M_SDIV); /* some delay between MPLL and UPLL */
delay (4000); ;USB时钟为48M /* configure UPLL */ clk_power->UPLLCON = ((U_M_MDIV << 12) + (U_M_PDIV << 4) + U_M_SDIV); /* some delay between MPLL and UPLL */
delay (8000); ;设置GPIO /* 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; ;初始化bd结构体中的bi_arch_number和bi_boot_params /* arch number of SMDK2410-Board */ gd->bd->bi_arch_number = MACH_TYPE_SMDK2410; /* adress of boot parameters */
gd->bd->bi_boot_params = 0x30000100; ;启用指令和数据cache ;通过对协处理器的操作了实现cache的使能 icache_enable(); dcache_enable(); return 0;
} int interrupt_init (void) { ;获取计时控制寄存器 S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS(); ;使用PWM定时器4 /* 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);
} static int env_init (void) { int crc1, crc1_ok; uchar *addr1; int crc2, crc2_ok;
uchar flag1, flag2, *addr2; //解析参数，定义了两个envdev_t型变量 //typedef struct envdev_s { //uchar devname[16]; /* Device name */ //ulong devoff; /* Device offset */ //ulong env_size; /* environment size */ //ulong erase_size; /* device erase size */ //} envdev_t; //程序中定义了/dev/mtd1和/dev/mtd2两个，parse_config函数用来初始化这两个结构体，并利用stat函数 //初始化一个struct stat结构体 if (parse_config ()) /* should fill envdevices */ return 1; //为参数分配空间，ENV_SIZE=CFG_ENV_SIZE - ENV_HEADER_SIZE=0x10000-sizeof(unsigned long) if ((addr1 = calloc (1, ENV_SIZE)) == NULL) { fprintf (stderr, "Not enough memory for environment (%ld bytes)n", ENV_SIZE); return (errno); } //从flash中读取参数 //typedef struct environment_s { //ulong crc; /* CRC32 over data bytes */ //uchar flags; /* active or obsolete */ //uchar *data; //} env_t; /* read environment from FLASH to local buffer */ //确定其指针 environment.data = addr1; curdev = 0; ;该函数用来将旧的参数从flash中擦除，然后将新的参数写入flash if (flash_io (O_RDONLY)) { return (errno); } ;进行crc校验 crc1_ok = ((crc1 = crc32 (0, environment.data, ENV_SIZE)) == environment.crc); if (!HaveRedundEnv) { if (!crc1_ok) { fprintf (stderr, "Warning: Bad CRC, using default environmentn"); memcpy(environment.data, default_environment, sizeof default_environment); } } else { flag1 = environment.flags; curdev = 1;
if ((addr2 = calloc (1, ENV_SIZE)) == NULL) { fprintf (stderr, "Not enough memory for environment (%ld bytes)n", ENV_SIZE); return (errno); } environment.data = addr2; if (flash_io (O_RDONLY)) {
return (errno); } crc2_ok = ((crc2 = crc32 (0, environment.data, ENV_SIZE))
== environment.crc); flag2 = environment.flags; if (crc1_ok && !crc2_ok) {
environment.data = addr1; environment.flags = flag1; environment.crc = crc1; curdev = 0; free (addr2); } else if (!crc1_ok && crc2_ok) { environment.data = addr2; environment.flags = flag2; environment.crc = crc2; curdev = 1; free (addr1); } else if (!crc1_ok && !crc2_ok) { fprintf (stderr, "Warning: Bad CRC, using default environmentn"); memcpy(environment.data, default_environment, sizeof default_environment); curdev = 0; free (addr1); } else if (flag1 == active_flag && flag2 == obsolete_flag) { environment.data = addr1; environment.flags = flag1; environment.crc = crc1; curdev = 0; free (addr2); } else if (flag1 == obsolete_flag && flag2 == active_flag) { environment.data = addr2; environment.flags = flag2; environment.crc = crc2; curdev = 1; free (addr1); } else if (flag1 == flag2) { environment.data = addr1; environment.flags = flag1; environment.crc = crc1; curdev = 0; free (addr2); } else if (flag1 == 0xFF) { environment.data = addr1; environment.flags = flag1; environment.crc = crc1; curdev = 0; free (addr2); } else if (flag2 == 0xFF) { environment.data = addr2; environment.flags = flag2; environment.crc = crc2; curdev = 1; free (addr1); } } return (0); } //如果参数中设置了波特率则利用参数用设置的波特率，否则利用默认的CONFIG_BAUDRATE(115200) 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);
} int serial_init (void)
{ //该函数设置uart的几个寄存器，包括FIFO寄存器、控制寄存器、列控制寄存器和波特率约数寄存器等 serial_setbrg (); return (0); } ;设置gd->have_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);
} //打印当前一些状态信息 static int display_banner (void) { printf ("nn%snn", version_string); debug ("U-Boot code: %08lX -> %08lX BSS: -> %08lXn", _armboot_start, _bss_start, _bss_end); #ifdef CONFIG_MODEM_SUPPORT debug ("Modem Support enabledn"); #endif #ifdef CONFIG_USE_IRQ debug ("IRQ Stack: %08lxn", IRQ_STACK_START); debug ("FIQ Stack: %08lxn", FIQ_STACK_START); #endif return (0);
} //初始化ram信息，设置起始地址和大小，从include/configs/smdk2410.h中获取这些信息 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;
} //显示ram信息，其中的宏也是从include/configs/smdk2410.h中读取 static int display_dram_config (void) { int i; #ifdef DEBUG
puts ("RAM Configuration:n"); for(i=0; i<CONFIG_NR_DRAM_BANKS; 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<CONFIG_NR_DRAM_BANKS; i++) {
size += gd->bd->bi_dram[i].size; } puts("DRAM: "); print_size(size, "n"); #endif return (0);
} //以上都是一些初始化的函数，可以看出以上这些函数都是为了初始化一个全局的结构体变量gd而执行的， //该变量地址由寄存器r8指向，该结构体定义了开发板的相关硬件配置，在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 */ #ifdef CONFIG_VFD unsigned char vfd_type; /* display type */ #endif #if 0 unsigned long cpu_clk; /* CPU clock in Hz! */ unsigned long bus_clk; unsigned long ram_size; /* RAM size */ unsigned long reset_status; /* reset status register at boot */ #endif void **jt; /* jump table */ } gd_t; */ void start_armboot (void)
{ init_fnc_t **init_fnc_ptr; char *s; #ifndef CFG_NO_FLASH ulong size; #endif #if defined(CONFIG_VFD) || defined(CONFIG_LCD) unsigned long addr; #endif /* Pointer is writable since we allocated a register for it */
//获取全局gd指针 gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t)); /* compiler optimization barrier needed for GCC >= 3.4 */ __asm__ __volatile__("": : :"memory"); //清空该结构体 memset ((void*)gd, 0, sizeof (gd_t)); //获取bd_info结构体指针 gd->bd = (bd_t*)((char*)gd - sizeof(bd_t)); memset (gd->bd, 0, sizeof (bd_t)); //整个代码区的长度 monitor_flash_len = _bss_start - _armboot_start; //调用初始化函数，用来初始化gd结构体 for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) { if ((*init_fnc_ptr)() != 0) { hang (); } } #ifndef CFG_NO_FLASH
/* configure available FLASH banks */ //board/smdk2410/flash.c配置flash //从其实现来看，好像只是配置nor flash size = flash_init (); //显示flash信息 display_flash_config (size); #endif /* CFG_NO_FLASH */ //定义显示类型 #ifdef CONFIG_VFD # ifndef PAGE_SIZE # define PAGE_SIZE 4096 # endif /* * reserve memory for VFD display (always full pages) */ /* bss_end is defined in the board-specific linker script */ //按页对其方式保留显存 addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1); size = vfd_setmem (addr); gd->fb_base = addr; #endif /* CONFIG_VFD */ //显示器为LCD，同上 #ifdef CONFIG_LCD # ifndef PAGE_SIZE # define PAGE_SIZE 4096 # endif /* * reserve memory for LCD display (always full pages) */ /* bss_end is defined in the board-specific linker script */ addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1); size = lcd_setmem (addr); gd->fb_base = addr; #endif /* CONFIG_LCD */ //初始化CFG_MALLOC_LEN大小空间 /* armboot_start is defined in the board-specific linker script */ mem_malloc_init (_armboot_start - CFG_MALLOC_LEN); //初始化nand flash，这是在nand flash启动的s3c2410移植u-boot的关键，根据flash时序编写函数即可
//在include/configs/smdk2410.h中的command definition中增加CONFIG_COMMANDS和CFG_CMD_NAND命令 #if (CONFIG_COMMANDS & CFG_CMD_NAND) puts ("NAND: "); nand_init(); //board/smdk2410/smdk2410.c #endif #ifdef CONFIG_HAS_DATAFLASH
AT91F_DataflashInit(); dataflash_print_info(); #endif /* initialize environment */
//初始化环境参数 env_relocate (); //framebuffer初始化 #ifdef CONFIG_VFD /* must do this after the framebuffer is allocated */ drv_vfd_init(); #endif /* CONFIG_VFD */ //通过命令行参数传递获取ip地址 /* IP Address */ gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr"); //通过命令行参数传递获取物理地址 /* 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; } #ifdef CONFIG_HAS_ETH1
i = getenv_r ("eth1addr", tmp, sizeof (tmp)); s = (i > 0) ? tmp : NULL; for (reg = 0; reg < 6; ++reg) {
gd->bd->bi_enet1addr[reg] = s ? simple_strtoul (s, &e, 16) : 0; if (s) s = (*e) ? e + 1 : e; } #endif } //调用相应驱动函数对硬件设备进行初始化 devices_init (); /* get the devices list going. */ #ifdef CONFIG_CMC_PU2
load_sernum_ethaddr (); #endif /* CONFIG_CMC_PU2 */ jumptable_init ();
//初始化串口 console_init_r (); /* fully init console as a device */ #if defined(CONFIG_MISC_INIT_R)
/* miscellaneous platform dependent initialisations */ misc_init_r (); #endif /* enable exceptions */
//启用中断 enable_interrupts (); /* Perform network card initialisation if necessary */
//初始化网卡 #ifdef CONFIG_DRIVER_CS8900 cs8900_get_enetaddr (gd->bd->bi_enetaddr); #endif #if defined(CONFIG_DRIVER_SMC91111) || defined (CONFIG_DRIVER_LAN91C96)
if (getenv ("ethaddr")) { smc_set_mac_addr(gd->bd->bi_enetaddr); } #endif /* CONFIG_DRIVER_SMC91111 || CONFIG_DRIVER_LAN91C96 */ /* 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 */ #ifdef BOARD_LATE_INIT
board_late_init (); #endif #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 (); } /* NOTREACHED - no way out of command loop except booting */
} //在board/smdk2410/smdk2410.c中增加nand flash初始化代码 /* * NAND flash initialization. */ // 在include/s3c24x0.h中由S3C2410_NAND结构体的定义，也就是定义了NFCONF、NFCMD、NFADDR和NFSTAT这 四个//寄存器，由于2410有flash控制器，因此可以直接通过flash控制器来对flash器件进行操作，如果芯片没有//flash控制器，有 的利用I/O端口来同flash交换数据，就必须利用I/O口来模式时序。比如44B0X就是利用GPIO //来进行flash读写的 #if (CONFIG_COMMANDS & CFG_CMD_NAND) typedef enum {
NFCE_LOW, NFCE_HIGH, } NFCE_STATE; extern unsigned long nand_probe(unsigned long physadr);
static inline void NF_Reset(void)
{ int i; //使能 NF_SetCE(NFCE_LOW); //写入命令 NF_Cmd(0xFF); // reset command //延时 for(i = 0; i < 10; i++); // tWB = 100ns. //通过R/B信号线，判断flash内部操作是否完成， NF_WaitRB(); // wait 200~500us; //芯片禁用 NF_SetCE(NFCE_HIGH); } static inline void NF_Init(void) { #if 0 // a little bit too optimistic #define TACLS 0 #define TWRPH0 3 #define TWRPH1 0 #else #define TACLS 0 #define TWRPH0 4 #define TWRPH1 2 #endif //首先根据NFCONF寄存器的各位定义对Nand flash进行初始化 NF_Conf((1<<15)|(0<<14)|(0<<13)|(1<<12)|(1<<11)|(TACLS<<8)|(TWRPH0<<4)|(TWRPH1<<0)); NF_Reset(); } void nand_init(void)
{ S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); NF_Init(); //利用drivers/nand_legacy/nand_legacy.c,在该文件中也添加这几个同nand flash相关的函数 printf ("%4lu MBn", nand_probe((ulong)nand) >> 20); } //操作控制寄存器，该寄存器为16位寄存器 static void NF_Conf(u16 conf) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); nand->NFCONF = conf; } //flash只有8位的输入、输出端口，直接向命令寄存器赋值即可写入命令 static void NF_Cmd(u8 cmd) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); nand->NFCMD = cmd; } static void NF_CmdW(u8 cmd)
{ NF_Cmd(cmd); udelay(1); } //写入地址 static void NF_Addr(u8 addr) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); nand->NFADDR = addr; } //芯片使能 static void NF_SetCE(NFCE_STATE s) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); //Nand flash memroy chip enable,如果NFCONF的第11位为1则nFCE使能，为1则禁止 switch (s) { case NFCE_LOW: nand->NFCONF &= ~(1<<11); break; case NFCE_HIGH: nand->NFCONF |= (1<<11); break; } } //等待flash内部操作完成 static void NF_WaitRB(void) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); while (!(nand->NFSTAT & 0x01)); } //向数据寄存器写入数据 static void NF_Write(u8 data) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); nand->NFDATA = data; } //读取数据 static u8 NF_Read(void) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); return(nand->NFDATA); } //校验 static void NF_Init_ECC(void) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); nand->NFCONF |= (1<<12); } //获取ECC code static u32 NF_Read_ECC(void) { S3C2410_NAND * const nand = S3C2410_GetBase_NAND(); return(nand->NFECC); } #endif 通过上面的描述要移植U-Boot到s3c2410上，并要从nand flash启动，则需要修改的地方有： 1、在start.S中增加将U-Boot从flash复制到ram中的代码 2、在include/configs/smdk2410.h中增加相关定义，主要是nand flash寄存器的定义，并针对具体平台对其中的参数进行配置，比如ram的大小等。 3、在board/smdk2410/smdk2410.c中增加nand flash的相关操作函数，如复位、写指令、读数据、查看状态等。 再编译U-Boot则可以看到flash的定义，并能通过网络下载内核和文件系统等。 当U-Boot进入main_loop后将等待用户输入，或者在定时时间超过时调用do_bootm_linux来启动linux内核， U-Boot为各个处理器的do_bootm_linux定义了固定的类型，定义了boot_os_Fcn函数类型。 typedef void boot_os_Fcn (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[], ulong addr, /* of image to boot */ ulong *len_ptr, /* multi-file image length table */ int verify); /* getenv("verify")[0] != 'n' */ cmdtp结构体用来保存命令以及参数，addr为启动镜像的地址，程序首先进入do_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; //定义最大的解压空间为8M uint unc_len = CFG_BOOTM_LEN; int i, verify; char *name, *s; int (*appl)(int, char *[]); //镜像文件的头部信息，传递给do_bootm_linux函数 image_header_t *hdr = &header; s = getenv ("verify");
verify = (s && (*s == 'n')) ? 0 : 1; //如果没有指定运行地址，则采用默认的地址，该地址在include/configs/smdk2410.h中定义为0x30008000 if (argc < 2) { addr = load_addr; } else { //如果参数中指定了地址，则从指定地址开始运行 addr = simple_strtoul(argv[1], NULL, 16); } //在文件开头定义CONFIG_SHOW_BOOT_PROGRESS函数用来显示当前内核运行到哪一步了 SHOW_BOOT_PROGRESS (1); printf ("## Booting image at %08lx ...n", addr); //系统中没有atmel的数据flash /* 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 //从镜像读取头部到结构header中 memmove (&header, (char *)addr, sizeof(image_header_t)); //通过头部结构体来获取magic、crc等数据 if (ntohl(hdr->ih_magic) != IH_MAGIC) { //i386 #ifdef __I386__ /* correct image format not implemented yet - fake it */ //通过头部结构体，检测镜像的格式是否正确 if (fake_header(hdr, (void*)addr, -1) != NULL) { /* to compensate for the addition below */ addr -= sizeof(image_header_t); /* turnof verify, * fake_header() does not fake the data crc */ verify = 0; } else #endif /* __I386__ */ //对于非i386平台 { puts ("Bad Magic Numbern"); SHOW_BOOT_PROGRESS (-1); return 1; } } //magic正确为第2步 SHOW_BOOT_PROGRESS (2); //校验crc data = (ulong)&header; len = sizeof(image_header_t); checksum = ntohl(hdr->ih_hcrc);
hdr->ih_hcrc = 0; if (crc32 (0, (uchar *)data, len) != checksum) {
puts ("Bad Header Checksumn"); SHOW_BOOT_PROGRESS (-2); return 1; } //校验成功为第3步 SHOW_BOOT_PROGRESS (3); #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 //对于多文件镜像的处理，这个部分是很有用的，特别对于容量很小的系统，有时候需要将代码段和数据段放//在不同的文件中
//显示镜像文件的信息，包括文件大小、创建时间、入口等 print_image_hdr ((image_header_t *)addr); //data为镜像文件头部后的第1个ulong数据，用来完成crc校验 data = addr + sizeof(image_header_t); //len为镜像问价的大小 len = ntohl(hdr->ih_size); //是否进行crc校验 if (verify) { puts (" Verifying Checksum ... "); if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) { printf ("Bad Data CRCn"); SHOW_BOOT_PROGRESS (-3); return 1; } puts ("OKn"); } //校验成功为第4步 SHOW_BOOT_PROGRESS (4); //数据指针 len_ptr = (ulong *)data; //校验cpu的体系结构 #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) #else # error Unknown CPU type #endif { printf ("Unsupported Architecture 0x%xn", hdr->ih_arch); SHOW_BOOT_PROGRESS (-4); return 1; } //体系结构校验成功为第5步 SHOW_BOOT_PROGRESS (5); //判断镜像文件类型 switch (hdr->ih_type) { //如果是独立的应用程序则利用第2个参数来作为加载地址 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 commandn", cmdtp->name); SHOW_BOOT_PROGRESS (-5); return 1; } //类型判断成功为第6步 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(); //处理cache #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 recovern"); 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 recovern", 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 %dn", hdr->ih_comp); SHOW_BOOT_PROGRESS (-7); return 1; } puts ("OKn"); //解压成功为第7步 SHOW_BOOT_PROGRESS (7); //如果是独立的应用程序，则根据autostart来确定是否自动启动程序 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; } //hdr->ih_ep为程序的入口 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 %dn", hdr->ih_type); SHOW_BOOT_PROGRESS (-8); return 1; } //成功为第8步 SHOW_BOOT_PROGRESS (8); //判断操作系统类型 switch (hdr->ih_os) { default: /* handled by (original) Linux case */ case IH_OS_LINUX: #ifdef CONFIG_SILENT_CONSOLE fixup_silent_linux(); #endif printf("boot linuxn"); //进入armlinux.c中的do_bootm_linux函数 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; } 进入文件lib_arm/arm_linux.c中的do_bootm_linux
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); //获取镜像的头部信息，header在cmd_bootm.c中定义 image_header_t *hdr = &header; //获取开发板信息 bd_t *bd = gd->bd; #ifdef CONFIG_CMDLINE_TAG
//获取bootargs参数 char *commandline = getenv ("bootargs"); #endif //调用内核入口函数,将内核入口函数指针赋给theKernel theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep); /*
* Check if there is an initrd image */ //看是否为initrd镜像 if (argc >= 3) { //如果为initrd为第9步 SHOW_BOOT_PROGRESS (9); //获取initrd镜像地址 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 //获取initrd头部西你想 memcpy (&header, (char *) addr, sizeof (image_header_t)); //校验magic if (ntohl (hdr->ih_magic) != IH_MAGIC) { printf ("Bad Magic Numbern"); SHOW_BOOT_PROGRESS (-10); do_reset (cmdtp, flag, argc, argv); } //校验crc 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 Checksumn"); SHOW_BOOT_PROGRESS (-11); do_reset (cmdtp, flag, argc, argv); } //校验成功为第10步 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 //checksum if (verify) { ulong csum = 0; printf (" Verifying Checksum ... ");
csum = crc32 (0, (unsigned char *) data, len); if (csum != ntohl (hdr->ih_dcrc)) { printf ("Bad Data CRCn"); SHOW_BOOT_PROGRESS (-12); do_reset (cmdtp, flag, argc, argv); } printf ("OKn"); } //成功为第11步 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 Imagen"); 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 */ } //判断是否为多文件内核镜像 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 */ //无initrd镜像 SHOW_BOOT_PROGRESS (14); len = data = 0;
} #ifdef DEBUG
if (!data) { printf ("No initrdn"); } #endif //确定initrd的起始地址和终止地址 if (data) { initrd_start = data; initrd_end = initrd_start + len; } else { initrd_start = 0; initrd_end = 0; } //成功为第15步 SHOW_BOOT_PROGRESS (15); //进入linux内核 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 //设置initrd参数 if (initrd_start && initrd_end) setup_initrd_tag (bd, initrd_start, initrd_end); #endif #if defined (CONFIG_VFD) || defined (CONFIG_LCD) //设置vfd、lcd参数 setup_videolfb_tag ((gd_t *) gd); #endif //结束参数设置 setup_end_tag (bd); #endif //启动内核 /* we assume that the kernel is in place */ printf ("nStarting kernel ...nn"); #ifdef CONFIG_USB_DEVICE
{ extern void udc_disconnect (void); udc_disconnect (); } #endif //在内核启动前的清除工作 cleanup_before_linux (); //调用内核 theKernel (0, bd->bi_arch_number, bd->bi_boot_params); } //开始设置启动参数 static void setup_start_tag (bd_t *bd) { params = (struct tag *) bd->bi_boot_params; params->hdr.tag = ATAG_CORE;
params->hdr.size = tag_size (tag_core); params->u.core.flags = 0;
params->u.core.pagesize = 0; params->u.core.rootdev = 0; params = tag_next (params);
}
|
|
|
来自： langhuayipian > 《bootloader》
