uboot 分析之 start.s

      最近给 Mini6410 添加开机启动画面和操作系统未启动时充电管理画面。使用的平台是友善的mini6410。
      由于操作系统未启动，大部分工作要在UBoot里进行完成。现在充电管理和开机动画基本实现，呵呵，中间经历了N多磨难啊 现在把做的工作记录下来。
      前面有两篇文章是介绍UBoot的makefile的。我们从makefile中看到编译生成的第一个目标文件是start.o，现在我们就从start.s进行分析。
      系统刚启动没有准备好C运行的堆栈，所以start.s实现为汇编。

#include <config.h>
#include <version.h>
#ifdef CONFIG_ENABLE_MMU
#include <asm/proc/domain.h>
#endif
#include <regs.h>

#ifndef CONFIG_ENABLE_MMU
#ifndef CFG_PHY_UBOOT_BASE
#define CFG_PHY_UBOOT_BASE CFG_UBOOT_BASE //使用了MMU 此处值为 0xc7e00000
#endif
#endif

/*
 *************************************************************************
 *
 * Jump vector table as in table 3.1 in [1]
 *
 *************************************************************************
 */
/*异常向量表*/
.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所在的地址处放入四字节的数据,这个数据就是undefined_instruction标号 
/* 的地址.意思就是说在当前_undefined_instruction对应的地址中放的是undefined_instruction的地址 
/*word伪操作用于分配一段字内存单元（分配的单元都是字对齐的），并用伪操作中的expr初始化。.long和.int作用与之相同。
_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
_pad:
 .word 0x12345678 /* now 16*4=64 */
.global _end_vect
_end_vect:

 .balignl 16,0xdeadbeef
/*
 *************************************************************************
 *
 * Startup Code (reset vector)
 *
 * do important init only if we don't start from memory!
 * setup Memory and board specific bits prior to relocation.
 * relocate armboot to ram
 * setup stack
 *
 *************************************************************************
 */
/*TEXT_BASE 在/board/config.mk文档中定义, 他定义了代码在运行时所在的地址, _TEXT_BASE中保存了这个地址
_TEXT_BASE:
 .word TEXT_BASE

/*
 * Below variable is very important because we use MMU in U-Boot.
 * Without it, we cannot run code correctly before MMU is ON.
 * by scsuh.
 */
_TEXT_PHY_BASE:
 .word CFG_PHY_UBOOT_BASE /*使用了MMU 此处值为 0xc7e00000*/


.globl _armboot_start/*声明全局标志. 声明的该标号_armboot_start可以被外部使用*/
_armboot_start:
 .word _start

/*
 * These are defined in the board-specific linker script.
 */
/*
BSS段 数据段 代码段 堆栈
声明：大部分来自于维基百科，自由的百科全书。
BSS段：在采用段式内存管理的架构中，BSS段（bsssegment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。
数据段：在采用段式内存管理的架构中，数据段（datasegment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。
代码段：在采用段式内存管理的架构中，代码段（codesegment / text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许自修改程序。 在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。
堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
栈(stack)：栈又称堆栈， 是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
*/
.globl _bss_start //bss段开始
_bss_start:
 .word __bss_start

.globl _bss_end //bss段结束
_bss_end:
 .word _end

#ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */
.globl IRQ_STACK_START/*预处理标号 目的:让IRQ_STACK_START指向地址0x0badc0de(这个需要根据硬件更改)*/
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
  */
/*EC: 模式位清零*//*bic是位清零(Bit Clear)指令，本语句是把r0的Bit[4:0]位清零(由0x1F指示)，然后把结果写入r0中。*/         
/*EC: 工作模式位设置为10011,为管理模式,irq fiq设置为1,屏蔽中断*/ 
/*orr指令是按位求或，本语句是r0的 Bit7,Bit6,Bit4,Bit1,Bit0 置为1，其它位保持不变。*/
/*执行完上述操作后，cpsr中的 I=1, F=1, T保持不变(默认为0)，M[4:0]=10011，意思是禁止IRQ，禁止FIQ，/*执行完上述操作后，cpsr中的 I=1, F=1, T保持不变(默认为0)，M[4:0]=10011，意思是禁止IRQ，禁止FIQ，工作在ARM状态，工作在SVC32模式。*/
 mrs r0,cpsr
 bic r0,r0,#0x1f
 orr r0,r0,#0xd3
 msr cpsr,r0

/*
 *************************************************************************
 *
 * CPU_init_critical registers
 *
 * setup important registers
 * setup memory timing
 *
 *************************************************************************
 */
         /*
         * we do sys-critical inits only at reboot,
         * not when booting from ram!
         */
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 */
/*协处理器指令用于扩展指令集Ｐ协处理器指令可用于提供附加的计算能力，有可用于控制包括cache和内存
 * 管理的存储子系统。协处理器指令包括数据处理指令，寄存器传输指令及内存传输指令。协处理器指令只用于带
 * 有协处理器的ARM内核。
 * CDP {<cond>} cp, opcode1, Cd, Cn{,opcode2}  协处理器数据处理 -- 在协处理器内部执行一个数据处理操作
 * <MRC/MCR> {<cond>} cp, opcode1, Rd, Cn, Cm{,opcode2} 协处理器寄存器传输 -- 把数据送入/取出协处理器寄存器
 * <LDC/STC> {<cod>} cp, Cd, addressing  协处理器内存比较 -- 从协处理器装载/存储一个内存数据块
 * 其中:cp域代表协处理器的编号，为p0~P15. opcode域描述要在协处理器中进行的操作。Cn, Cm及Cd描述在协处理器中的寄存器。
 * 协处理器15(CP15)是为系统控制预留的，如内存管理，写缓冲控制，cache控制及寄存器识别等。
 * MRC p15,0,r10,c0,c0,0 把协处理器15寄存器c0的内容拷贝到r10中，cp15寄存器c0中包含处理器标识，其内容拷贝到通用寄存器r10
 */ 
 /*
  * 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

 /* Peri port setup */
 ldr r0, =0x70000000
 orr r0, r0, #0x13
     mcr p15,0,r0,c15,c2,4 @ 256M(0x70000000-0x7fffffff)


 /*
  * Go setup Memory and board specific bits prior to relocation.
  */
 bl lowlevel_init /* go setup pll,mux,memory */

 /* when we already run in ram, we don't need to relocate U-Boot.
  * and actually, memory controller must be configured before U-Boot
  * is running in ram.
  *//*此处如果当前地址和原始定义的起始地址相同则跳过代码复制*/
 ldr r0, =0xff000fff
 bic r1, pc, r0 /* r0 <- current base addr of code */
 ldr r2, _TEXT_BASE /* r1 <- original base addr in ram */
 bic r2, r2, r0 /* r0 <- current base addr of code */
 cmp r1, r2 /* compare r0, r1 */
 beq after_copy /* r0 == r1 then skip flash copy */

#ifdef CONFIG_BOOT_NAND
 mov r0, #0x1000
 bl copy_from_nand /*copy uboot to ram from nand*/
#endif

after_copy: /*对指示灯进行操作*/
 ldr r0, =ELFIN_GPIO_BASE
 ldr r1, =0xC00
 str r1, [r0, #GPPDAT_OFFSET]
 ldr r1, [r0, #GPFPUD_OFFSET]
 bic r1, r1, #0xc0000000
 orr r1, r1, #0x80000000
 str r1, [r0, #GPFPUD_OFFSET]
 ldr r1, [r0, #GPFDAT_OFFSET]
 orr r1, r1, #0x8000
 str r1, [r0, #GPFDAT_OFFSET]
 ldr r1, [r0, #GPFCON_OFFSET]
 bic r1, r1, #0xc0000000
 orr r1, r1, #0x40000000
 str r1, [r0, #GPFCON_OFFSET]


#ifdef CONFIG_ENABLE_MMU
enable_mmu:
 /* enable domain access */
 ldr r5, =0x0000ffff
 mcr p15, 0, r5, c3, c0, 0 @ load domain access register

 /* Set the TTB register */
 ldr r0, _mmu_table_base
 ldr r1, =CFG_PHY_UBOOT_BASE
 ldr r2, =0xfff00000
 bic r0, r0, r2
 orr r1, r0, r1
 mcr p15, 0, r1, c2, c0, 0

 /* Enable the MMU */
mmu_on:
 mrc p15, 0, r0, c1, c0, 0
 orr r0, r0, #1 /* Set CR_M to enable MMU */
 mcr p15, 0, r0, c1, c0, 0
 nop
 nop
 nop
 nop
#endif

skip_hw_init:
 /* Set up the stack */
stack_setup: //设置栈地址 
#ifdef CONFIG_MEMORY_UPPER_CODE
 ldr sp, =(CFG_UBOOT_BASE + CFG_UBOOT_SIZE - 0xc)
#endif
//设置BSS段
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

 ldr pc, _start_armboot /*跳转到SDRAM中运行*/

_start_armboot:        
 .word start_armboot

#ifdef CONFIG_ENABLE_MMU
_mmu_table_base:
 .word mmu_table
#endif

/*
 * copy U-Boot to SDRAM and jump to ram (from NAND or OneNAND)
 * r0: size to be compared
 * Load 1'st 2blocks to RAM because U-boot's size is larger than 1block(128k) size
 */
 .globl copy_from_nand
copy_from_nand:
 mov r10, lr /* save return address */

 mov r9, r0
 /* get ready to call C functions */
 ldr sp, _TEXT_PHY_BASE /* setup temp stack pointer */
 sub sp, sp, #12
 mov fp, #0 /* no previous frame, so fp=0 */
 mov r9, #0x1000
// ldr r0, =ELFIN_UART_BASE
// ldr r1, =0x4b4b4b4b
// str r1, [r0, #UTXH_OFFSET]
 bl copy_uboot_to_ram

3: tst r0, #0x0 /*copy_uboot_to_ram返回0 复制成功*/
 bne copy_failed
 /*Stepping Stone start address 0x0c000000*/
 ldr r0, =0x0c000000
 ldr r1, _TEXT_PHY_BASE
1: ldr r3, [r0], #4
 ldr r4, [r1], #4
 teq r3, r4
 bne compare_failed /* not matched */
 subs r9, r9, #4
 bne 1b /* 此处循环测了一段4k 相同 */

4: mov lr, r10 /* all is OK */
 mov pc, lr

copy_failed:
 nop /* copy from nand failed */
 b copy_failed

compare_failed:
 nop /* compare failed */
 b compare_failed

/*
 * we assume that cache operation is done before. (eg. cleanup_before_linux())
 * actually, we don't need to do anything about cache if not use d-cache in U-Boot
 * So, in this function we clean only MMU. by scsuh
 *
 * void theLastJump(void *kernel, int arch_num, uint boot_params);
 */
#ifdef CONFIG_ENABLE_MMU
 .globl theLastJump
theLastJump:
 mov r9, r0
 ldr r3, =0xfff00000
 ldr r4, _TEXT_PHY_BASE
 adr r5, phy_last_jump
 bic r5, r5, r3
 orr r5, r5, r4
 mov pc, r5
phy_last_jump:
 /*
  * disable MMU stuff
  */
 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

 mcr p15, 0, r0, c8, c7, 0 /* flush v4 TLB */

 mov r0, #0
 mov pc, r9
#endif
/*
 *************************************************************************
 *
 * 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 @ carve out a frame on current user stack
 stmia sp, {r0 - r12} @ Save user registers (now in svc mode) r0-r12

 ldr r2, _armboot_start
 sub r2, r2, #(CFG_MALLOC_LEN)
 sub r2, r2, #(CFG_GBL_DATA_SIZE+8) @ set base 2 words into abort stack
 ldmia r2, {r2 - r3} @ get values for "aborted" pc and cpsr (into parm regs)
 add r0, sp, #S_FRAME_SIZE @ grab pointer to old stack

 add r5, sp, #S_SP
 mov r1, lr
 stmia r5, {r0 - r3} @ save sp_SVC, lr_SVC, pc, cpsr
 mov r0, sp @ save current stack into r0 (param register)
 .endm

 .macro irq_save_user_regs
 sub sp, sp, #S_FRAME_SIZE
 stmia sp, {r0 - r12} @ Calling r0-r12
 add r8, sp, #S_PC @ !!!! R8 NEEDS to be saved !!!! a reserved stack spot would be good.
 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 (enter in banked mode)
 sub r13, r13, #(CFG_MALLOC_LEN) @ move past malloc pool
 sub r13, r13, #(CFG_GBL_DATA_SIZE+8) @ move to reserved a couple spots for abort stack

 str lr, [r13] @ save caller lr in position 0 of saved stack
 mrs lr, spsr @ get the spsr
 str lr, [r13, #4] @ save spsr in position 1 of saved stack

 mov r13, #MODE_SVC @ prepare SVC-Mode
 @ msr spsr_c, r13
 msr spsr, r13 @ switch modes, make sure moves will execute
 mov lr, pc @ capture return pc
 movs pc, lr @ jump to next instruction & switch modes.
 .endm

 .macro get_bad_stack_swi
 sub r13, r13, #4 @ space on current stack for scratch reg.
 str r0, [r13] @ save R0's value.
 ldr r0, _armboot_start @ get data regions start
 sub r0, r0, #(CFG_MALLOC_LEN) @ move past malloc pool
 sub r0, r0, #(CFG_GBL_DATA_SIZE+8) @ move past gbl and a couple spots for abort stack
 str lr, [r0] @ save caller lr in position 0 of saved stack
 mrs r0, spsr @ get the spsr
 str lr, [r0, #4] @ save spsr in position 1 of saved stack
 ldr r0, [r13] @ restore r0
 add r13, r13, #4 @ pop stack entry
 .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_swi
 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
 .align 5
.global arm1136_cache_flush
arm1136_cache_flush:
  mcr p15, 0, r1, c7, c5, 0 @ invalidate I cache
  mov pc, lr @ back to caller

#if defined(CONFIG_INTEGRATOR) && defined(CONFIG_ARCH_CINTEGRATOR)
/* Use the IntegratorCP function from board/integratorcp/platform.S */
#elif defined(CONFIG_S3C64XX)
/* For future usage of S3C64XX*/
#else
 .align 5
.globl reset_cpu
reset_cpu:
 ldr r1, rstctl /* get addr for global reset reg */
 mov r3, #0x2 /* full reset pll+mpu */
 str r3, [r1] /* force reset */
 mov r0, r0
_loop_forever:
 b _loop_forever
rstctl:
 .word PM_RSTCTRL_WKUP
#endif 

可以看出 start.s主要做的工作就是ARM初始化 lowlevel_init 下节分析。把nandflah中的代码读到SDRAM，设置堆栈和初始化BSS段。通过ldrpc, _start_armboot 跳转到SDRAM中执行C代码 start_armboot 。 下一节我们主要分析 lowlevel_init、copy_uboot_to_ram及start_armboot 做了哪些工作。 参考：http://blog.csdn.net/ecbtnrt/article/details/6630085